Tesseract Decoder: Quantum MLE Decoding

• Tesseract decoder is a quantum error correction tool that employs an A* search algorithm to efficiently explore vast error spaces while meeting syndrome constraints.
• It leverages pruned combinatorial graphs and admissible detector-based heuristics to optimize decoding speed and maintain high accuracy for various LDPC quantum codes.
• Low-level optimizations, such as refined data structures and hardware-accelerated bitwise operations, deliver significant speedups for real-time and large-scale QEC applications.

The Tesseract decoder is a Most-Likely-Error (MLE) decoder for quantum error correction (QEC) that leverages an A* search algorithm to efficiently explore an exponentially large error hypothesis space. This approach enables both high accuracy and substantial speedups in decoding low-density parity-check (LDPC) quantum codes. Tesseract is applicable to a wide range of QEC code families, notably including surface codes, color codes, bivariate-bicycle codes, and protocols involving transversal CNOT operations on neutral-atom quantum hardware. Recent advances have focused on low-level optimizations which further accelerate the decoding process, making Tesseract practical for real-time and large-scale quantum error correction scenarios (Beni et al., 14 Mar 2025, Grbic et al., 3 Feb 2026).

1. Fundamental Principles and Algorithmic Structure

Tesseract formulates the quantum MLE decoding problem as a shortest-path search on an implicit combinatorial graph. Each node in this graph corresponds to a candidate subset of physical errors, and edges represent the addition of single errors. The decoding process aims to identify the subset with the minimal total negative log-likelihood, subject to syndrome constraints imposed by the observed detector outcomes.

Given a set of elementary errors $\mathscr{E} = \{e_1, \dots, e_N\}$ (each with occurrence probability $p(e)$), and a set of detectors $\mathscr{D} = \{d_1,\dots,d_K\}$, the decoder searches for $F \subseteq \mathscr{E}$ such that the syndrome constraint $D(F) = \mathscr{S}$ is satisfied, where $D(F)$ denotes the binary sum (XOR) of all detectors affected by $F$. The MLE objective is to minimize:

$$\min_{F \subseteq \mathscr{E},\; D(F) = \mathscr{S}} w(F) = \sum_{e \in F} w(e), \qquad w(e) = -\frac{\log p(e)}{\log(1 - p(e))}$$

Tesseract employs an A* search, where for each candidate state $F$:

• $g(F)$ is the accumulated cost.
• $h(F)$ is an admissible heuristic estimating the minimum remaining cost to reach a syndrome-correct subset.
• $f(F) = g(F) + h(F)$ governs the priority queue.

Admissibility is maintained by constructing $h(F)$ as a per-detector lower bound, ensuring A* will produce the globally optimal solution when the EXIT node is first reached.

Pruning rules, such as canonical ordering and limiting multiple error assignments per detector, transform the combinatorial search graph into a pruned tree, allowing for significant reductions in computational workload while preserving optimality (Beni et al., 14 Mar 2025, Grbic et al., 3 Feb 2026).

2. Heuristic Design and Search Optimizations

The admissible heuristic $h(F)$ is computed using the residual syndrome vector $x = \mathscr{S} \oplus D(F)$, tracking which detectors remain unsatisfied. For each such detector $d$, Tesseract selects the minimal effective cost per detector count among non-forbidden errors. This yields:

$$h(F) = \sum_{d \in x} \min_{e \in E(d),\, e \notin J} \frac{w(e)}{|D(e) \cap x|}$$

Here, $E(d)$ is the set of errors incident on $d$, and $J$ is the set of forbidden errors according to path pruning. The use of a detector-based heuristic (normalized by detector counts and including optional penalties) maintains admissibility and guides the A* search efficiently through the highest-probability regions of the hypothesis space (Beni et al., 14 Mar 2025).

To further optimize practical decoding, Tesseract implements additional heuristics:

• Beam cutoff: Discards nodes whose residual is larger than the current minimum by a beam-width parameter, balancing speed and solution completeness.
• Syndrome no-revisit: Prevents exploration of duplicate residual syndromes, eliminating redundant paths.
• Ensemble reordering and beam climbing: Runs the search over several random orderings of detectors or varying beam parameters, returning the best decoding result.

3. Implementation and Low-Level Performance Enhancements

Tesseract’s core structures employ bit-packed vectors for representing error subsets and syndromes, with critical open and closed sets tracked via binary heaps and hash tables for fast lookup and update.

Advancements in low-level optimization have achieved substantial speedups without altering decoding logic or accuracy. The principal strategies include (Grbic et al., 3 Feb 2026):

1. Elimination of std::vector<bool> Overhead: Substituting byte-addressable std::vector<char> for boolean vectors involved in graph pruning and syndrome revisiting, which removes proxy-object access costs, delivers up to 40% speedup in surface codes and 17–32% for color and bicycle codes.
2. Memory Layout Optimization (SoA→AoS): Reorganizing data from scattered arrays (struct-of-arrays) to a single array of structs (array-of-structs) for get_detcost kernels, improving cache locality and decreasing cache miss rates. This produces up to 2.75× speedup in get_detcost for bivariate-bicycle code configurations where this kernel is the primary performance bottleneck.
3. Early-Exit with Pre-computed Lower Bounds: For each detector-error adjacency, pre-computing lower bounds on cost and sorting adjacency lists allows rapid early termination in minimum-finding inner loops, which reduces computational cost of get_detcost by an additional 10–20%, reaching up to 3.5× cumulative speedup with the memory reorganization.
4. Hardware-Accelerated Bit-wise Hashing: Adopting boost::dynamic_bitset<> for syndrome pattern hashing exploits word-level CPU primitives for hashing and bitwise ops, reducing hashing iterations by approximately an order of magnitude and yielding up to 30% speedup for beam-intensive searches.

Measured LLC and L1 cache miss rates drop by up to 90% and 15–35% respectively in demanding codes, directly correlating with observed runtime improvements (Grbic et al., 3 Feb 2026).

4. Empirical Performance and Benchmarking

Empirical studies on Xeon-class CPUs demonstrate that the Tesseract decoder delivers substantial speed benefits over integer-programming baselines while maintaining exact MLE decoding. Detailed benchmarks reveal:

Code Family	Typical Speedup	Peak Speedup
Color Codes	2.0×–2.2×	2.21×
Bivariate-Bicycle	2.4×–3.1×	5.24×
Surface Codes	2.3×–2.7×	2.66×
Transversal CNOT	2.4×–2.8×	2.75×

For surface code ($d = 11$) and color code ($d = 13$) at $p = 10^{-3}$, Tesseract achieves logical error rates ($\sim1.3 \times 10^{-4}$ and $\sim3.6 \times 10^{-5}$ respectively) that match IP-based decoding, but with $\sim 5\times$ reductions in average decode time. The decoder remains effective on large-scale protocols, such as transversal CNOT on neutral-atom architectures, where alternative implementations become computationally impractical (Beni et al., 14 Mar 2025, Grbic et al., 3 Feb 2026).

5. Comparative Analysis and Applications

Tesseract's MLE guarantee ensures that high-rate quantum codes, such as bivariate-bicycle codes, achieve their full efficiency potential, outperforming matching and BP+OSD techniques. For instance, at logical error rates $\sim 10^{-4}$, the $[[288,12,10]]$ bicycle code requires 14–19× fewer qubits than surface codes using Tesseract, versus only 10× for matching/BP+OSD. Performance advantages persist, though at reduced ratios, in noisy-coupler scenarios (4× vs 2×) (Beni et al., 14 Mar 2025).

A notable application is syndrome extraction and decoding in surface code CNOT protocols for neutral-atom devices, where Tesseract is the only exact decoder meeting practical timing constraints for circuits with $\sim 600$ detectors and $\sim 450$ error events.

6. Scalability, Engineering Lessons, and Future Directions

The demonstrated reductions in decoding latency (2–5× per shot) advance the feasibility of Tesseract for real-time QEC feedback, larger code distances ($d>11$), and higher error rates with longer search beams. This level of performance is attributed to rigorous profiling, targeted data structure selection, and maximization of data locality and hardware primitives during critical kernel operations (Grbic et al., 3 Feb 2026).

Key engineering lessons include:

• Optimization of seemingly minor data structures (e.g., bool-vectors) can dominate application runtime.
• Data layout (SoA vs AoS) decisions substantially affect memory hierarchy performance.
• Hardware-supported bitsets and aggressive use of early-exit strategies are highly effective in exponential search algorithms.

Proposed future enhancements encompass hardware acceleration (GPU/FPGA offloading), adaptive search parameterization, JIT-compiled code-family-specific kernels, and integration with custom hardware decoders for ultra-low-latency QEC. Algorithmic improvements such as tighter admissible heuristics, hybrid BP-guided search, and automatic search parameter tuning represent ongoing research foci (Grbic et al., 3 Feb 2026, Beni et al., 14 Mar 2025).

7. Limitations and Open Problems

Practical scalability is ultimately limited by the exponential search space: for very high code rates or physical error rates, Tesseract may hit resource or beam/PQ limits, producing heralded (low-confidence) failure modes. The overhead of running repeated ensemble trials for parameter reordering is non-negligible in such regimes. Further research is ongoing to develop tighter heuristics, heuristic-hybrid algorithms, adaptive parameter controls, and more efficient hardware backends. The implementation is available as open-source software, facilitating community development and benchmarking (Beni et al., 14 Mar 2025, Grbic et al., 3 Feb 2026).