COSETTE: Coset Ensemble Decoder

• COSETTE is a coset ensemble decoder that leverages the degeneracy in stabilizer codes by targeting logical-equivalent cosets instead of individual error chains.
• It combines UF-style clustering with ensemble forest exploration and reverse-order elimination to approximate maximum-likelihood coset decoding efficiently.
• The hardware co-design, featuring multi-bank memory access and pipelining, achieves a superior accuracy–latency trade-off compared to traditional MWPM and UF decoders.

Searching arXiv for the specified COSETTE paper and closely related quantum-error-correction decoder work. Found relevant arXiv entries for the COSETTE decoder, including the target paper and related MWPM/UF-style decoder context. COSETTE denotes the algorithm–hardware co-design built around the coset ensemble decoder for quantum error correction. It is introduced for fault-tolerant architectures in which a classical decoder must convert streamed syndromes into corrections with both high logical accuracy and ultra-low latency. The defining departure from vanilla Union-Find (UF) and from physical-chain-centric decoding is that COSETTE explicitly decodes at the level of logical-equivalence cosets in degenerate stabilizer codes, rather than only searching for a single most likely physical error chain. In the reported implementation and evaluation, this coset-aware strategy is coupled to a domain-specific FPGA architecture designed for temporal resource reuse, multi-bank memory access, and low-stall pipelining, yielding a better accuracy–latency trade-off than vanilla MWPM and UF under a circuit-level depolarizing noise model (Liang et al., 9 Jun 2026).

1. Definition and conceptual basis

COSETTE is defined in the source paper as the co-design around coset ensemble decoding, a decoder that improves UF by exploiting the fact that many physically distinct errors are degenerate: they produce the same syndrome and the same logical effect. In this setting, the relevant target is not the most likely physical error chain,

$E^{*}=\argmax_{E\in\mathcal{P}_n}\{p(E|s)\},$

but the most likely logical coset,

$L^{*} = \argmax_L\{p(L|s)\}.$

The paper formulates the stabilizer decomposition as

$E = s(E)\cdot t(s)\cdot l(E)=(s(E)l(E))\cdot t(s),$

where $t(s)$ is the pure-error term fixed by the syndrome, $s(E)\in\mathcal S$ is a stabilizer deformation, and $l(E)\in\mathcal L$ is the logical part. Errors that differ only by stabilizers are therefore degenerate and belong to the same logical-equivalent coset, described as

$\{E|E=S_gt(s)L,\forall S_g\in\mathcal{S}\}.$

This formulation places degeneracy at the center of decoder design. The conceptual shift is significant because, for degenerate stabilizer codes such as the surface code, the decoder objective is naturally expressed in terms of logical classes rather than individual chains. A plausible implication is that COSETTE should be understood less as a variant of UF in the narrow procedural sense than as a redefinition of the decoding target itself: UF-style machinery is retained, but the optimization criterion is elevated from physical recovery paths to logical-equivalence cosets (Liang et al., 9 Jun 2026).

2. Coset-aware decoding objective

The paper’s central theoretical claim is that logical-equivalent candidates should be aggregated at the coset level. It proves that if two candidates share the same logical outcome $L$, then they are degenerate: $$E_1E_2^{\dagger}=\left(S_1t(s)L\right)\left(S_2t(s)L\right)^{\dagger}=S_1S_2.$$ This identifies them as belonging to the same logical-equivalent coset.

The corresponding decision rule is an approximation to coset-level maximum-likelihood decoding. Across $K$ randomized decoding runs, the decoder estimates posterior mass by sample frequency,

$L^{*} = \argmax_L\{p(L|s)\}.$0

and selects

$L^{*} = \argmax_L\{p(L|s)\}.$1

In practice, the vote is restricted to the candidates with the smallest correction size $L^{*} = \argmax_L\{p(L|s)\}.$2, which the paper states empirically improves accuracy; when all candidates have the same size, the rule reduces exactly to majority vote over logical outcomes. This is presented as a tractable surrogate for the intractable coset maximum-likelihood objective.

One common misconception is that degeneracy-aware decoding merely adds randomization to UF. The paper’s description is more specific: randomization is used only to generate multiple coset-consistent candidates, while the actual inference target remains the most probable logical coset. The ensemble is therefore not an end in itself; it is a sampling mechanism for approximating posterior mass over logical classes (Liang et al., 9 Jun 2026).

3. Algorithmic pipeline

The algorithm begins with standard UF-style clustering, which partitions the decoding graph into syndrome graphs. COSETTE then introduces its main new stage, ensemble forest exploration (EFE), executed $L^{*} = \argmax_L\{p(L|s)\}.$3 times with distinct randomized vertex and edge priorities. For sample $L^{*} = \argmax_L\{p(L|s)\}.$4, the priority function is generated by hashing: $L^{*} = \argmax_L\{p(L|s)\}.$5

Given these priorities, the subroutine PriorityForests constructs a deterministic forest by visiting vertices and adjacency lists in ascending priority order. The construction stores a discovery order $L^{*} = \argmax_L\{p(L|s)\}.$6 and a parent array. The forest is then processed by Reverse-Order Elimination (ROE), which scans vertices in reverse discovery order: $L^{*} = \argmax_L\{p(L|s)\}.$7 If $L^{*} = \argmax_L\{p(L|s)\}.$8, the algorithm keeps edge $L^{*} = \argmax_L\{p(L|s)\}.$9 and flips parities. ROE returns a candidate correction $E = s(E)\cdot t(s)\cdot l(E)=(s(E)l(E))\cdot t(s),$0 and its logical outcome $E = s(E)\cdot t(s)\cdot l(E)=(s(E)l(E))\cdot t(s),$1.

The role of ROE is structurally important. The paper describes it as a linear-time replacement for a separate leaf-detection and recomputation phase. This eliminates a second global pass over the forest and turns the stored traversal metadata into a direct peeling schedule. The resulting sampled set $E = s(E)\cdot t(s)\cdot l(E)=(s(E)l(E))\cdot t(s),$2 is then aggregated at the logical level as described above.

This pipeline is best understood as a layered modification of UF rather than a wholesale replacement. Clustering remains UF-like, but forest construction is diversified through randomized priority orderings, and final inference is moved from a single-chain choice to coset-level aggregation (Liang et al., 9 Jun 2026).

4. Overhead reduction: ROE and lossless graph compression

Because ensemble exploration introduces repeated forest construction, COSETTE adds two explicit overhead-reduction mechanisms.

The first is Reverse-Order Elimination, already noted above, which “eliminates global leaf detection and degree recomputation” by reusing the traversal order recorded during forest construction. The second is lossless graph compression. After clustering, the decoder keeps only “the edges between roots and the edges between roots and boundaries during merging,” rather than the full graph. The paper gives an illustrative reduction in which graph size decreases from 21 to 8 while preserving the dataflow required by the algorithm.

These two techniques are paired deliberately. Graph compression reduces the working set before ensemble exploration, while ROE reduces the per-sample cost of turning a forest into a correction candidate. The paper states that together they reduce the extra work introduced by ensemble exploration without sacrificing accuracy (Liang et al., 9 Jun 2026).

This design addresses a predictable criticism of ensemble-based decoders: that improved logical performance may come at prohibitive memory and control overhead. COSETTE’s response is not to deny the added work, but to restructure it so that the additional cost is constrained by compression and single-pass elimination.

5. Hardware architecture and algorithm–hardware co-design

The hardware realization is organized as a two-stage architecture: a fully pipelined clustering engine followed by $E = s(E)\cdot t(s)\cdot l(E)=(s(E)l(E))\cdot t(s),$3 parallel EFE instances and a voting module. The guiding principle is temporal resource reuse. Rather than spatially replicating the entire decoder as code distance grows, the design reuses a single pipelined clustering datapath over time. The paper explicitly presents this as a way to avoid the code-distance-proportional resource growth associated with prior spatial architectures.

Two hardware optimizations are singled out. The first is multi-bank memory hashing, which distributes the 3D lattice across banks so that a center vertex and its axis-aligned neighbors can be accessed concurrently without conflicts. The bank function is

$E = s(E)\cdot t(s)\cdot l(E)=(s(E)l(E))\cdot t(s),$4

with $E = s(E)\cdot t(s)\cdot l(E)=(s(E)l(E))\cdot t(s),$5, and $E = s(E)\cdot t(s)\cdot l(E)=(s(E)l(E))\cdot t(s),$6. The bank-internal address is then packed densely by lexicographic rank. The stated objective is to reduce bank conflicts during cluster growth and merging.

The second is hierarchical ID mapping, which inserts an intermediate Root-ID (RID) between Vertex-ID (VID) and Cluster-ID (CID). Cluster merges then update a compact $E = s(E)\cdot t(s)\cdot l(E)=(s(E)l(E))\cdot t(s),$7 table rather than rewriting numerous scattered VID-to-CID entries. The paper characterizes this as collapsing write fan-out and sharply lowering memory traffic.

The clustering pipeline itself is described as a 7-stage pipeline processing one VID per cycle, with forwarding/bypass logic and the hashed memory system used to keep the pipeline busy. In this sense, COSETTE is not simply an algorithm later ported to hardware; its algorithmic form is constrained by what can be streamed, hashed, and reused efficiently on FPGA. That co-dependence is fundamental to the system’s identity (Liang et al., 9 Jun 2026).

6. Evaluation, scaling behavior, and tunability

The evaluation uses a circuit-level depolarizing noise model implemented with Stim. For a code of distance $E = s(E)\cdot t(s)\cdot l(E)=(s(E)l(E))\cdot t(s),$8, depolarizing noise of rate $E = s(E)\cdot t(s)\cdot l(E)=(s(E)l(E))\cdot t(s),$9 is applied to data qubits after Clifford operations and between syndrome rounds; measurement errors are modeled as classical bit flips with the same probability $t(s)$0, reset operations are ideal, and unless otherwise stated the configuration is $t(s)$1 and $t(s)$2 repeated syndrome rounds. The paper also evaluates phenomenological and biased phenomenological noise, although the main algorithmic accuracy figures use the circuit-level model (Liang et al., 9 Jun 2026).

Under this model, the reported result is a better accuracy–latency trade-off than vanilla MWPM and UF. With $t(s)$3, the decoder tracks MWPM closely at small code distances and remains substantially better than UF; at larger distances, the gap to MWPM grows somewhat, but the paper states that it can be reduced by increasing $t(s)$4. The decoder also remains sub-microsecond over the tested range and can outperform Micro-Blossom at small distances while using much less hardware.

The implementation metrics reported for FPGA resource usage are similarly specific. The design uses 108k LUTs, about 8.0× fewer than Micro-Blossom and roughly 4.3× fewer than QUEKUF. The abstract further states up to 8.2× LUT reduction versus reported UF-based decoder resources. The tunable candidate number $t(s)$5 serves as a direct accuracy–cost knob: increasing $t(s)$6 improves accuracy while increasing only the branch-parallel hardware term linearly, leaving the shared clustering engine and voting logic unchanged.

The paper fits the empirical law

$t(s)$7

and defines a practical threshold

$t(s)$8

as the smallest $t(s)$9 capturing 70% of the logical-error-rate improvement. This makes $s(E)\in\mathcal S$0 not only an implementation parameter but an explicit systems-level control variable for adapting decoder behavior to different fault-tolerant workloads.

7. Position within quantum error correction

COSETTE’s main significance lies in the way it bridges a theory–hardware gap in quantum error correction. On the theory side, it exploits stabilizer-code degeneracy through coset-aware decoding and approximates coset maximum-likelihood inference by ensemble sampling and voting. On the systems side, it implements that approximation in a memory- and pipeline-efficient FPGA architecture whose resource growth is moderated by temporal reuse, hashed bank placement, and hierarchical identifier remapping (Liang et al., 9 Jun 2026).

The paper’s stated takeaway is that this produces a decoder more accurate than UF, much faster and smaller than heavy MWPM implementations, and tunable enough to adapt to different fault-tolerant workloads. A plausible implication is that COSETTE occupies an intermediate point in the decoder design space: it does not attempt exact coset maximum-likelihood decoding, but neither does it accept the physical-chain objective implicit in standard UF. Instead, it samples the coset structure aggressively enough to improve logical behavior while preserving a low-latency hardware profile.

In that sense, COSETTE is best viewed as a decoder architecture for scalable fault-tolerant quantum computation in which algorithmic degeneracy handling and hardware-conscious execution are treated as a single design problem rather than separate layers.