QCFuse: Fusion Methods in RAG & Quantum

Updated 4 July 2026

QCFuse is a family of fusion methods that combine structured units under strict validity or fault-tolerance constraints in both language and quantum frameworks.
In retrieval-augmented generation, QCFuse uses compressed query-aware anchors to selectively recompute tokens, boosting inference speed and accuracy.
In quantum applications, QCFuse fuses quantum mass functions or qubits to discount conflicting evidence and enable robust decision making and fault tolerance.

In current arXiv usage, QCFuse is not a single standardized method but a family of research constructs that share a fusion-oriented design logic. The term appears explicitly in retrieval-augmented generation as query-aware KV cache fusion for efficient large-language-model serving (Yan et al., 30 Mar 2026), and in Quantum Dempster–Shafer Theory as a QCI-based conflict fusion method for decision making and out-of-distribution detection (Dong et al., 10 May 2025). Closely related, though not always identically named, usages include qubit fusion and qudit fission for fault-tolerant quantum computation (Moussa, 2015), encoded fusion and fusion networks in photonic fault tolerance (Song et al., 2024), and broader quantum fusion mechanisms in circuit synthesis and multimodal learning (Beaudoin et al., 29 Apr 2025, Nguyen et al., 8 Oct 2025).

1. Terminological scope and principal senses

The most direct contemporary referents of QCFuse are two lines of work. In language-model systems, QCFuse denotes a query-aware cache fusion framework that reuses precomputed per-chunk KV caches and selectively recomputes request-relevant tokens during RAG prefill (Yan et al., 4 Jun 2026). In uncertainty-aware decision making, QCFuse denotes a QCI-based conflict fusion pipeline that discounts conflicting quantum mass functions and fuses them for downstream inference (Dong et al., 10 May 2025). Other papers are adjacent rather than terminologically identical: some explicitly state that the term “QCFuse” does not appear in the paper, even though the underlying mechanism is a quantum fusion procedure (Beaudoin et al., 29 Apr 2025, Nguyen et al., 8 Oct 2025).

Research line	Core object being fused	Representative paper
Query-aware RAG serving	Per-chunk KV caches and selectively recomputed tokens	(Yan et al., 4 Jun 2026)
Quantum conflict fusion	Quantum mass functions in QDST	(Dong et al., 10 May 2025)
Qubit fusion	Two qubits into one four-dimensional qudit	(Moussa, 2015)
Encoded photonic fusion	Logical Bell-fusion measurements in FBQC	(Song et al., 2024)
Diffusion-based circuit synthesis	Layer-, node-, and edge-level circuit structure	(Beaudoin et al., 29 Apr 2025)
Quantum multimodal fusion	Modality features via a quantum fusion layer	(Nguyen et al., 8 Oct 2025)

A recurrent misconception is that QCFuse must denote a single algorithm or software artifact. The literature does not support that reading. Instead, the label functions as a domain-specific shorthand for methods that compose structured units under explicit validity or fault-tolerance constraints. This suggests a family resemblance rather than a single canonical definition.

2. Query-aware cache fusion for retrieval-augmented generation

In RAG serving, QCFuse addresses the fact that full prefill over retrieved context dominates time-to-first-token, while naive prefix caching fails whenever chunk ordering or prompt composition changes. The formal setup models the retrieved context as

$C = [c_1; c_2; \cdots; c_m],$

with $N = \sum_{i=1}^m |c_i|$ tokens, and defines a recomputation set $\mathcal{P}$ through the ratio

$\rho = |\mathcal{P}| / N.$

Full prefill constructs

$KV^{Full}(C) = \{(K_C^l, V_C^l)\}_{l=1}^L,$

whereas position-independent chunk caches are stitched into

$KV^{PIC}(C) = [\Pi_1(KV_1^{PIC}); \Pi_2(KV_2^{PIC}); \cdots; \Pi_m(KV_m^{PIC})],$

with the mismatch

$KV^{PIC}(C) \neq KV^{Full}(C)$

arising from absent cross-chunk contextualization (Yan et al., 4 Jun 2026).

The central innovation is compressed-view query-aware selection. Instead of inspecting all layers over the full context before recomputation, QCFuse constructs a compact proxy using per-chunk anchors and a small set of critical layers. Offline, each chunk obtains an anchor set

$\mathcal{A}_i = \mathrm{TopK}(G_i, \lceil r_a |c_i| \rceil),$

and the anchor-stitched context is

$C_{\mathcal{A}} = [c_1[\mathcal{A}_1]; c_2[\mathcal{A}_2]; \cdots; c_m[\mathcal{A}_m]].$

Online, anchor-conditioned query states are computed as

$Q_U^l(C_{\mathcal{A}}) \leftarrow \mathrm{LLM}^l(U; KV^{\mathcal{A}}(C_{\mathcal{A}})),$

and token importance is aggregated only over the profiled critical-layer set $N = \sum_{i=1}^m |c_i|$ 0:

$N = \sum_{i=1}^m |c_i|$ 1

The selector then forms $N = \sum_{i=1}^m |c_i|$ 2 (Yan et al., 4 Jun 2026).

This design is motivated by a systems constraint rather than only a modeling preference. Full-view query-aware selectors such as ProphetKV require broad KV visibility before recomputation and therefore serialize selection in a way that stalls the layer-wise cache-fusion pipeline. QCFuse avoids that stall by reducing both the token view and the layer view. The later arXiv formulation fixes KVzip@10% as the default anchor ratio and Top-3 profiled middle layers as the critical-layer budget, while the earlier demonstration version describes the same idea as semantic summary anchors and a single critical middle layer chosen to preserve pipeline efficiency (Yan et al., 4 Jun 2026, Yan et al., 30 Mar 2026).

3. Systems architecture, implementation, and reported gains in RAG inference

The serving stack is implemented in SGLang, with PagedAttention, a Triton-optimized sparse recomputation path, and a storage hierarchy in which full per-chunk KV caches reside on SSD, anchors reside in CPU memory, and active layer K/V are streamed to GPU (Yan et al., 4 Jun 2026). The earlier demonstration likewise describes a location-aware sparse attention Triton kernel, pipelined recomputation, and an extension of SGLang’s RadixCache for chunk-level KV lookup and stitching (Yan et al., 30 Mar 2026). The architectural theme is to keep selection short enough that recomputation at layer $N = \sum_{i=1}^m |c_i|$ 3 can overlap with loading layer $N = \sum_{i=1}^m |c_i|$ 4.

The performance claims are specific and strong. The demonstration paper reports that QCFuse is ≈2× faster than full computation on TTFT, yields ≈40% additional latency reduction vs. strong cache-fusion baselines at matched accuracy, and delivers ROUGE-L improvements of 2.3–3.5 points over CacheBlend across settings; at a 40% recomputation ratio, accuracy matches full computation, and on HotpotQA QCFuse exceeds full computation by 0.8 ROUGE-L because of an attention denoising effect (Yan et al., 30 Mar 2026). The later and broader evaluation extends the study to four open-weight LLMs across six datasets and reports that, at matched quality, QCFuse achieves an average prefill-time speedup of 1.7x over full prefill and 1.5x over ProphetKV (Yan et al., 4 Jun 2026).

The reported datasets and models are also concrete. The demonstration evaluates Llama3.1-8B, Qwen3-8B, Mistral-v0.3-7B on Musique, 2WikiMQA, HotpotQA (Yan et al., 30 Mar 2026). The later work evaluates Mistral-v0.3-7B, Llama-3.1-8B, Qwen3-8B, Qwen3-14B on MuSiQue, 2WikiMQA, HotpotQA, together with RULER controlled-retrieval tasks mq, mv, vt (Yan et al., 4 Jun 2026). A notable systems result is bandwidth sensitivity: the full-view selector in ProphetKV can become selection-bound, and at a 30% recomputation ratio its selection stage consumes 34% of end-to-end time in the Qwen3-8B setting reported, whereas QCFuse keeps “select-in-prefill” small because it loads only anchors and critical-layer keys (Yan et al., 4 Jun 2026).

From a deployment perspective, the method is retriever-agnostic and exploits overlap across retrieved chunks rather than changes to the retriever itself. Its primary assumptions are access to per-chunk PIC caches, the ability to run query-only forwards over anchor prefixes, and a runtime capable of sparse token recomputation without breaking causal masking. The papers emphasize that QCFuse is complementary to kernel-level optimizations such as FlashAttention and to serving-level mechanisms such as speculative decoding, because it specifically targets the prefill/fusion regime rather than decoding or dense attention kernels (Yan et al., 30 Mar 2026).

4. QCFuse as QCI-based conflict fusion in Quantum Dempster–Shafer Theory

A second explicit usage defines QCFuse as a QCI-based conflict fusion method for Quantum Dempster–Shafer Theory. In this setting, evidence is represented by a quantum mass function

$N = \sum_{i=1}^m |c_i|$ 5

with normalization $N = \sum_{i=1}^m |c_i|$ 6, and conflict between two QMFs is quantified through the Quantum Correlation Coefficient

$N = \sum_{i=1}^m |c_i|$ 7

followed by the Quantum Conflict Indicator

$N = \sum_{i=1}^m |c_i|$ 8

The paper states that QCI satisfies non-negativity, symmetry, boundedness, extreme consistency and insensitivity to refinement (Dong et al., 10 May 2025).

The fusion procedure itself discounts sources according to pairwise consistency. For a set of QMFs $N = \sum_{i=1}^m |c_i|$ 9, the support degree is

$\mathcal{P}$ 0

and the discount coefficient is

$\mathcal{P}$ 1

Discounted QMFs are then fused by iterative DRC-QM to produce the final result (Dong et al., 10 May 2025). The formal motivation is that high-conflict sources should be suppressed before combination, rather than only normalized away after combination.

This QCFuse pipeline is embedded in C-DDS and C-DDS+ for out-of-distribution detection. The method constructs class-specific quantum description vectors, removes “individualistic features,” fuses class members with QCFuse, and derives an OOD decision function and class-specific domain threshold. C-DDS+ then combines the C-DDS score with a logit-based DML score using PCR5 (Dong et al., 10 May 2025).

The reported empirical gains are explicit. Across the benchmark suite, the approach achieves an average increase in Area Under the Receiver Operating Characteristic Curve (AUC) of 1.2% and a corresponding average decrease in False Positive Rate at 95% True Negative Rate (FPR95) of 5.4% compared to the optimal baseline method (Dong et al., 10 May 2025). Representative model-level results include VGG16, where C-DDS+ reaches average AUC 93.58% and FPR95 26.20%, compared with DML at average AUC 91.58% and FPR95 29.62%; and Swin-B, where C-DDS+ reaches average AUC 98.07% and FPR95 8.26% (Dong et al., 10 May 2025). The paper also notes that PCR5+ and PCR6+ become impractical for larger frames or larger evidence sets because of their very high complexity, which is part of the motivation for the QCI-based route.

5. Qubit fusion, encoded fusion, and fusion-based fault-tolerant quantum computation

In quantum information, one established usage of QCFuse is a circuit-level framework that treats a pair of qubits as a single four-dimensional qudit. Its defining algebraic statement is the nesting

$\mathcal{P}$ 2

where qudit Clifford operations become qubit non-Clifford operations after fusion and fission. The fusion map $\mathcal{P}$ 3 sends two qubits to a $\mathcal{P}$ 4 qudit, while $\mathcal{P}$ 5 reverses that encoding. The resource state is

$\mathcal{P}$ 6

and one, two, and three copies of $\mathcal{P}$ 7 suffice for T, controlled-S, and Toffoli resource extraction, respectively (Moussa, 2015). The same framework reports a threshold around $\mathcal{P}$ 8 for a greedy nesting of error-detection gadgets and an input/output ratio ≈ 6.8 for quadratic error reduction (Moussa, 2015).

A distinct but related line compiles circuit primitives directly into fusion networks via gate teleportation. In this construction, a Type-II fusion measures the commuting observables $\mathcal{P}$ 9 and $\rho = |\mathcal{P}| / N.$ 0, and CNOT is implemented by fusing data qubits into a 4-qubit linear cluster. Applied to the foliated surface code, this yields two new fault-tolerant fusion network architectures: a four-qubit model and a ten-qubit model. The paper reports pseudothresholds of ≈ 12.8% erasure and ≈ 1.33% error for the ten-qubit model, compared with ≈ 6.4% erasure and ≈ 0.58% error for the four-qubit model (Avanesov et al., 2024). The ten-qubit architecture improves thresholds by reducing multi-edges in the syndrome graph.

Another development is encoded-fusion-based quantum computation with linear optics. Here, each physical fusion is replaced by an encoded Bell measurement based on a generalized Shor code, with logical measurements of $\rho = |\mathcal{P}| / N.$ 1 and $\rho = |\mathcal{P}| / N.$ 2. The encoded-fusion success probability is given by

$\rho = |\mathcal{P}| / N.$ 3

with the paper reporting that this approach achieves up to 10 times higher loss thresholds than nonencoded fusion approaches with limited numbers of photons used in fusion (Song et al., 2024). The quoted thresholds include ≈4.8% for (2,2) encoding on 6-ring with $\rho = |\mathcal{P}| / N.$ 4, and ≈11.44% for 4-star plus ≈13.97% for 6-ring with (7,4) encoding, both approaching ≈14% as $\rho = |\mathcal{P}| / N.$ 5 increase (Song et al., 2024).

Fusion has also been extended to qLDPC codes with quantum emitters. That construction implements arbitrary CSS qLDPC codes through photonic fusions and emitter-generated resource states, with a case study on Bivariate Bicycle codes. For the [[144,12,12]] code, the reported pseudo-thresholds are 0.181% for Pauli error and 8.70% for erasure; under a modified sequential repeat-until-success strategy, the photon-loss pseudo-threshold saturates around ≈ 3% at $\rho = |\mathcal{P}| / N.$ 6 (Chen et al., 21 Sep 2025). The paper emphasizes that the resulting performance is comparable with topological architectures despite the substantially higher encoding rate.

Taken together, these quantum-computing usages show that “fusion” can mean at least three technically distinct operations: basis-changing qubit-to-qudit conversion, teleported gate realization inside fusion networks, and encoded entangled measurements that raise fusion success under loss. The shared structural theme is that a constrained entangling primitive becomes the interface between logical modules.

Several recent works are closely aligned with the QCFuse idea even when the exact label is absent. “Q-Fusion: Diffusing Quantum Circuits” explicitly states that the term “QCFuse” is not used in the paper and that the closest match is Q-Fusion, a diffusion-model-based, graph-native generator of quantum circuits that adapts LayerDAG to gate-arity, wiring, and ordering constraints (Beaudoin et al., 29 Apr 2025). In all reported non-parametric experiments—2-qubit, 8-gate; 2-qubit, 32-gate; and 5-qubit, 32-gate—the model generated 100% valid circuits (Beaudoin et al., 29 Apr 2025). The term “fusion” here refers not to gate fusion but to the composition of node counts, node types, and edges into valid DAG-encoded circuits.

In multimodal learning, “Expressive and Scalable Quantum Fusion for Multimodal Learning” introduces the Quantum Fusion Layer (QFL) and explicitly notes that “QCFuse” does not explicitly appear in the paper, even though QFL “embodies precisely a quantum–classical fusion mechanism” (Nguyen et al., 8 Oct 2025). QFL alternates state preparation $\rho = |\mathcal{P}| / N.$ 7 and parameterized unitaries $\rho = |\mathcal{P}| / N.$ 8 to realize a degree- $\rho = |\mathcal{P}| / N.$ 9 multivariate polynomial

$KV^{Full}(C) = \{(K_C^l, V_C^l)\}_{l=1}^L,$ 0

with a theorem guaranteeing that $KV^{Full}(C) = \{(K_C^l, V_C^l)\}_{l=1}^L,$ 1 is a matrix-valued polynomial of total degree at most $KV^{Full}(C) = \{(K_C^l, V_C^l)\}_{l=1}^L,$ 2 (Nguyen et al., 8 Oct 2025). Empirically, QFL reaches Accuracy 86.42% and F1 0.8376 on Multimodal Entailment, AUC 0.887 on PTB-XL (12 modalities) using 280,399 params, and ROC AUC 0.9151 on Traffic-LA (Nguyen et al., 8 Oct 2025).

A looser, analogical use appears in the summary of “Microscopic Investigation of Fusion and Quasifission Dynamics,” which describes a TDHF-centered framework in the “QCFuse” spirit rather than as a named method (Li et al., 10 Mar 2026). There the workflow couples DC-FHF, CCFULL, a TDHF-informed fusion-by-diffusion injection point, and a statistical survival model, yielding $KV^{Full}(C) = \{(K_C^l, V_C^l)\}_{l=1}^L,$ 3 for $KV^{Full}(C) = \{(K_C^l, V_C^l)\}_{l=1}^L,$ 4 and showing that tensor-force effects in $KV^{Full}(C) = \{(K_C^l, V_C^l)\}_{l=1}^L,$ 5 shift quasi-fission yields toward $KV^{Full}(C) = \{(K_C^l, V_C^l)\}_{l=1}^L,$ 6 and $KV^{Full}(C) = \{(K_C^l, V_C^l)\}_{l=1}^L,$ 7 (Li et al., 10 Mar 2026). This is not a standard terminological use of QCFuse, but it illustrates how the label can be invoked to describe a hybrid fusion workflow.

This suggests a broader conceptual pattern. Across RAG serving, QDST, circuit generation, multimodal learning, and fault-tolerant quantum computing, “QCFuse” and adjacent labels repeatedly denote mechanisms that fuse partial structures while preserving a hard constraint: semantic relevance, evidential consistency, circuit validity, polynomial expressivity, or fault tolerance. The term is therefore best understood not as a single method name with one provenance, but as a cluster of technically distinct fusion frameworks whose meanings are determined by discipline-specific context.