SOME: Symmetric One-Hot Matching Elector

• SOME is a quantum error correction decoder that reformulates syndrome pairing as a one-hot QUBO task with symmetric constraints.
• It employs a multi-seed greedy algorithm to construct minimum-weight involutive permutation matrices, enabling rapid, microsecond-scale decoding.
• The approach significantly reduces the variable count compared to MWPM and Ising-based decoders, balancing lower complexity with a modest threshold trade-off.

Symmetric One-Hot Matching Elector (SOME) is a decoder for surface-code quantum error correction that reformulates decoding as a Quadratic Unconstrained Binary Optimization (QUBO) problem and then solves a constrained matching task through a lightweight greedy construction of self-inverse permutation matrices. In the underlying One-Hot QUBO (OHQ), each binary variable represents whether a given pair of flipped syndromes is matched, with shortest-chain error probabilities encoded as weights and one-hot constraints enforcing that each flipped syndrome is matched exactly once. The resulting feasible solutions are symmetric one-hot matrices, equivalently involutive permutation matrices. The decoder was introduced as a low-topological-complexity alternative to Minimum-Weight Perfect Matching (MWPM), Union-Find (UF), and Ising-model-based decoders, with reported reductions in variable count and single-threaded decoding times in the microsecond regime (Guo et al., 31 Jul 2025).

1. Problem setting and decoder rationale

Conventional QEC decoders such as MWPM and UF are described as offering high thresholds and fast decoding, respectively, while both suffering from high topological complexity. Ising model-based decoders reduce topological complexity but demand considerable decoding time. SOME is positioned against this background as a decoder that retains a compact optimization representation while replacing slow global optimization with a lightweight constructive procedure (Guo et al., 31 Jul 2025).

The decoding task begins with a syndrome extraction round that produces $n$ flipped syndromes labeled $0,1,\dots,n-1$. SOME treats decoding as the problem of selecting a matching over these syndromes, including the possibility of matching a syndrome to itself to encode a boundary match. This reformulation is central: instead of manipulating a large topological data structure, the method constructs a permutation object whose entries directly encode syndrome pairings.

A key distinction in the presentation is between OHQ and SOME. OHQ denotes the QUBO formulation of the decoding problem. SOME denotes the specific algorithm that solves the problem by constructing candidate involutions from low-weight seeds and selecting the minimum-energy result. This suggests a conceptual separation between the optimization model and the lightweight decoder that approximates its solution.

2. One-Hot QUBO formulation

The binary variables are defined by

$x_{ij}\in\{0,1\},\quad 0\le i\le j<n,$

where $x_{ij}=1$ exactly when syndrome $i$ is matched to syndrome $j$. The diagonal case $i=j$ represents a self-match, interpreted as matching to the boundary (Guo et al., 31 Jul 2025).

Let $W=[w_{ij}]$ be the $n\times n$ weight matrix, where $w_{ij}$ is proportional to the log-likelihood, equivalently the number of physical errors, of the shortest chain connecting syndromes $0,1,\dots,n-1$0 and $0,1,\dots,n-1$1. The weights are chosen as

$0,1,\dots,n-1$2

so that each physical error is counted once in the total. The QUBO objective is then

$0,1,\dots,n-1$3

where $0,1,\dots,n-1$4 is the vector of all distinct $0,1,\dots,n-1$5 with $0,1,\dots,n-1$6, and $0,1,\dots,n-1$7 is a large penalty set to $0,1,\dots,n-1$8 for code distance $0,1,\dots,n-1$9.

The penalty term

$x_{ij}\in\{0,1\},\quad 0\le i\le j<n,$0

enforces one-hotness at the row level: each syndrome must appear exactly once in the matching matrix row associated with that syndrome. Together with the symmetry condition

$x_{ij}\in\{0,1\},\quad 0\le i\le j<n,$1

these constraints imply that any feasible binary matrix $x_{ij}\in\{0,1\},\quad 0\le i\le j<n,$2 is symmetric and one-hot, hence a self-inverse permutation matrix. The paper characterizes this structure as symmetric one-hot encoding.

This formulation makes the decoder’s combinatorial object explicit. Rather than searching over arbitrary binary assignments, the feasible set is restricted to binary matrices that are at once valid matchings and involutions, which sharply constrains the solution space.

3. Symmetric one-hot encoding and involutions

A permutation matrix $x_{ij}\in\{0,1\},\quad 0\le i\le j<n,$3 is self-inverse when

$x_{ij}\in\{0,1\},\quad 0\le i\le j<n,$4

Equivalently, each row and column contains exactly one $x_{ij}\in\{0,1\},\quad 0\le i\le j<n,$5, and the induced map $x_{ij}\in\{0,1\},\quad 0\le i\le j<n,$6 satisfies $x_{ij}\in\{0,1\},\quad 0\le i\le j<n,$7 (Guo et al., 31 Jul 2025).

In the decoder, this structure encodes the matching relation. If syndrome $x_{ij}\in\{0,1\},\quad 0\le i\le j<n,$8 is matched to syndrome $x_{ij}\in\{0,1\},\quad 0\le i\le j<n,$9, then the permutation must also map $x_{ij}=1$0 to $x_{ij}=1$1. If a syndrome is matched to itself, the corresponding diagonal entry is active. The involution property therefore captures both ordinary pairings and boundary matches in a single matrix representation.

For $x_{ij}=1$2, the paper gives the example

$x_{ij}=1$3

which corresponds to the matches $x_{ij}=1$4 and a self-match at $x_{ij}=1$5. In vector form this is written as $x_{ij}=1$6, where $x_{ij}=1$7 means $x_{ij}=1$8.

This matrix-theoretic view is more than a notational convenience. It provides the basis for the decoder’s reduced representation: instead of carrying a full binary optimization state with auxiliary constructions, SOME works with a length-$x_{ij}=1$9 permutation vector $i$0, one integer entry per flipped syndrome. A plausible implication is that the decoder’s memory footprint and update logic become simpler because feasibility is preserved through direct construction of involutions rather than through post hoc repair of arbitrary assignments.

4. Algorithmic construction in SOME

SOME recasts the QUBO search over $i$1 into a multi-seed greedy construction of involutions. The input is a sorted list

$i$2

of all pairs with $i$3, ordered by ascending weight and with ties broken in favor of off-diagonal entries (Guo et al., 31 Jul 2025).

The procedure identifies the smallest weight $i$4 and the number $i$5 of pairs at that weight. For each seed index $i$6, it initializes an empty permutation vector $i$7 and an empty used set, seeds the construction with $i$8, and sets $i$9 and $j$0. It then scans the remainder of $j$1 in ascending order and greedily appends a pair $j$2 whenever neither endpoint has already been used. If two or more self-mapped indices remain, it attempts pairwise swaps among those indices when such swaps lower the total weight. The total energy is computed as

$j$3

and the algorithm returns the best permutation $j$4 over all seeds.

The maintained data structures are a length-$j$5 integer array $j$6, a hash or set $j$7, and the single sorted list $j$8. Ties in weight are broken by preferring off-diagonal seeds first, with simple first-come breaking in the greedy appending loop. A seed run terminates once $j$9 is a complete involution, meaning every index has been assigned.

The method is therefore not presented as an exact optimizer over the OHQ landscape. It is a QUBO-inspired constructive decoder that begins from minimum-weight local evidence and extends toward a complete involution under strict feasibility constraints. This is consistent with the later observation that its greedy pruning sacrifices some threshold relative to the OHQ global optimum.

5. Computational complexity, variable count, and implementation

SOME uses exactly $i=j$0 integer entries in the vector $i=j$1, one per flipped syndrome, so its variable count is linear, $i=j$2. By contrast, MWPM and UF must represent all $i=j$3 data-qubit or syndrome variables and, in the state-of-the-art Ising approach, auxiliary variables for cubic or quartic terms. For code distance $i=j$4 at $i=j$5 physical error, the state-of-the-art Ising method is reported to use approximately $i=j$6 binary variables, while SOME uses approximately $i=j$7, corresponding to a reduction of about $i=j$8; in typical regimes, the reduction is stated as up to $i=j$9 (Guo et al., 31 Jul 2025).

Each seed construction scans the pair list $W=[w_{ij}]$0, whose size is $W=[w_{ij}]$1, so the worst-case work per seed is $W=[w_{ij}]$2. Because the number of seeds $W=[w_{ij}]$3 is the multiplicity of the minimum weight and remains small in practice, the overall work is given as $W=[w_{ij}]$4. The principal bottlenecks are sorting the $W=[w_{ij}]$5 weight-pair list and scanning it once per seed.

Implementation is described as optimized C++ called from Python, with memory overhead consisting of $W=[w_{ij}]$6 integers plus the weight-pair list. The decoder is also described as amenable to easy parallelism: different seeds or different syndrome rounds can be decoded concurrently on multi-core or GPU/FPGA platforms.

On a single Intel Core-i5 CPU, for distances up to $W=[w_{ij}]$7 and realistic physical error rates of $W=[w_{ij}]$8, decoding completes in a few microseconds. Figure 1 is described as showing locally measured single-thread times from approximately $W=[w_{ij}]$9\,µs at low error to sub-millisecond in worst-case patterns. The paper explicitly connects this regime to the superconducting-qubit requirement of a microsecond-scale feedback loop (Guo et al., 31 Jul 2025).

6. Performance profile, trade-offs, and limitations

The reported logical-error threshold depends on whether one considers the OHQ formulation solved via a QUBO annealer or the SOME greedy search. The OHQ formulation solved via a QUBO annealer yields a threshold of about $n\times n$0, described as slightly above MWPM’s best $n\times n$1 and above previous Ising-decoder thresholds of approximately $n\times n$2. SOME’s own greedy search achieves about an $n\times n$3 threshold, which is described as still adequate for current physical error rates of $n\times n$4 (Guo et al., 31 Jul 2025).

The time-performance comparison is similarly bifurcated. Table VII is described as showing that OHQ on an annealer is approximately $n\times n$5 faster than the state of the art while remaining in the millisecond scale. SOME, by contrast, is the microsecond-scale CPU decoder. This distinction matters because the strongest threshold figure in the presentation belongs to the OHQ optimization solved by annealing, whereas the strongest latency figure belongs to the SOME constructive decoder.

The main limitation stated in the paper is that greedy pruning sacrifices some threshold. Runtime also degrades in pathological high-error regimes because $n\times n$6 grows, pushing execution toward millisecond scales. Future work is explicitly framed in heuristic terms: incorporating TSP-inspired heuristics such as genetic algorithms or advanced local search into the seed-extension or diagonal-swap phase could close the gap to the OHQ global optimum and push the threshold back toward $n\times n$7 or beyond.

A common source of confusion is therefore the relation between OHQ and SOME. The data support a clear distinction: OHQ is the optimization formulation with a reported $n\times n$8 threshold under annealing, while SOME is the lightweight greedy decoder with microsecond-scale CPU runtime and an approximately $n\times n$9 threshold. Treating them as performance-identical would conflate the global optimization result with the heuristic decoder.

7. Position within decoder design for surface-code QEC

SOME occupies a specific design point among surface-code decoders. Relative to MWPM and UF, it is presented as avoiding high topological complexity. Relative to Ising-model-based decoders, it is presented as avoiding heavy decoding time. Its central innovation is to convert the decoding task into the construction of minimum-weight involutive permutations under symmetric one-hot constraints, thereby connecting QEC decoding, QUBO structure, and permutation-matrix feasibility in a single framework (Guo et al., 31 Jul 2025).

The reported combination of properties is internally coherent: linear variable count in the number of flipped syndromes, $w_{ij}$0 work driven by a sorted pair list, extremely low memory overhead, and microsecond-scale decoding on commodity CPUs. The threshold trade-off indicates that this efficiency is obtained by replacing a global optimizer with a constrained greedy search. This suggests that SOME is best understood not as a direct substitute for every high-threshold decoder, but as a low-latency decoding strategy whose approximation quality is explicitly bounded by its heuristic construction.

In summary, the decoder converts quantum-error decoding into finding a minimum-weight involutive permutation through a symmetric one-hot QUBO perspective and a multi-seed greedy algorithm. Within the paper’s reported results, that combination yields substantial variable-count reduction, practical microsecond latency on a single CPU thread, and logical-error performance that remains competitive with established decoder families while exposing a clear threshold-versus-speed trade-off.