Temporally Encoded Lattice Surgery (TELS)

• Temporally Encoded Lattice Surgery (TELS) is a protocol that speeds up fault-tolerant quantum computation by encoding fast, noisy syndrome measurements with classical error-correcting codes.
• It reduces the number of required measurement rounds and space-time resources by using an over-complete set of Pauli measurements, achieving up to a 2.2× runtime reduction in benchmarks.
• TELS integrates with magic state distillation and hybrid soft-information schemes to optimize scheduling and resource allocation for scalable surface code architectures.

Temporally Encoded Lattice Surgery (TELS) is a protocol designed to accelerate and optimize fault-tolerant quantum computation based on surface code architectures by reducing the time overhead associated with syndrome measurement rounds in lattice surgery operations. It achieves this by encoding measurement outcomes in the time domain using classical error-correcting codes, thereby enabling detection and correction of timelike errors while maintaining, or even decreasing, the overall runtime and space-time resource requirements.

1. Motivation and Principles of Temporally Encoded Lattice Surgery

Standard lattice surgery implements logical operations (e.g., multi-qubit Pauli measurements) through repeated rounds of syndrome extraction across patch boundaries, with the measurement time determined by the code distance $d_m$. A longer $d_m$ suppresses logical measurement errors (so-called "timelike" errors), but at the cost of increased runtime and accumulated hardware resources (proportional to the product of number of operations and $d_m$).

TELS addresses the time bottleneck by deliberately executing faster (shorter $d_m$) lattice-surgery measurements that may be more noisy, and by redundantly encoding measurement outcomes using a classical $[n, k, d]$ code. This redundancy ensures that errors in the measurement record can be detected—and, for sufficiently high code distance $d$, corrected—thereby allowing the system to maintain targeted logical error rates while reducing the average number of syndrome rounds per operation (Chamberland et al., 2021, Prabhu et al., 2022).

Mathematically, for a set $\mathcal{P}$ of $k$ multi-qubit Pauli measurements performed via lattice surgery, TELS augments the protocol by measuring an over-complete set $\mathcal{S}$ of $n > k$ Pauli products, with measurement outcomes that form codewords of a classical code:

$$Q[\vec{x}] := \prod_{j=0}^{k-1} P_{t+j}^{x_j},\quad \forall\, \vec{x}\in\mathbb{F}_2^k$$

One checks these outcomes for validity against the code's parity checks, thereby performing a classical error syndrome extraction on the measurement history.

2. TELS Protocol: Temporal Encoding via Classical Codes

The TELS protocol replaces the standard approach of performing $d_m \sim d$ rounds of syndrome measurement per Pauli measurement with the following procedure (Chamberland et al., 2021, Prabhu et al., 2022):

1. Fast Lattice-Surgery Measurements: For each logical Pauli in the parallelizable set, perform a small number $d_m' < d$ of syndrome rounds, recording the measurement outcomes. This leads to a higher raw logical measurement error rate that would be unacceptable in the absence of error correction.
2. Redundant Measurement Encoding: Extend the set of measurements to an over-complete set of size $n$, corresponding to codewords in a chosen $[n, k, d]$ classical error-correcting code. For example, for $k=2$, one could measure $P_1$, $P_2$, and $P_1P_2$, corresponding to a $[3,2,2]$ code.
3. Classical Decoding: The outcomes of all $n$ measurements are checked for validity using the code's parity check matrix. If the syndrome is all-zero, the result is accepted; otherwise, the round is declared a failure (rectifiable by repeating the encoded measurements), or, in an error-correcting variant, the error is decoded and the output corrected classically.
4. Logical Error Probability: The probability that $d$ or more of the $n$ encoded measurements fail sets the overall error. Because the probability of a raw lattice-surgery failure per measurement is $P_{\mathrm{err}} \sim p^{c(d_m' + 1)}$ (with $p$ physical error rate and $c$ a constant), the probability of an undetected logical error becomes $O(P_{\mathrm{err}}^d)$, exponentially smaller in $d$.

The consequence is that the code distance per measurement $d_m'$ can be substantially reduced without increasing the algorithm's logical error rate, yielding a net speed-up. For example, in practical benchmarks, TELS achieves a factor of 2.2 reduction in algorithm runtime while also decreasing space-time volume (Chamberland et al., 2021, Prabhu et al., 2022).

3. Magic State Distillation with TELS

Magic state distillation, a central ancillary routine in Clifford+$T$ fault-tolerant architectures, requires many non-Clifford multi-qubit Pauli measurements. The overhead for these resource states typically dominates the space-time cost.

TELS integrates with state distillation protocols by grouping the constituent Pauli measurements into parallelizable sets and applying temporal encoding as above. For protocols such as the 15-to-1, 116-to-12, or other large factories, TELS selects suitable classical codes (e.g., BCH, Golay, Hamming) tailored to the number and structure of the required measurements. The encoded procedure reduces the required $d_m'$ per measurement, thereby lowering both the runtime and the temporal storage burden for magic states (Prabhu et al., 2022). When combined with computation in the Clifford frame, further layout and scheduling optimizations are realized, notably in architectures with asymmetric (biased) noise where spatial and temporal code distances are matched to the dominant error mode.

A central formula relates the logical error probability per Pauli in TELS:

$$p_L = \frac{1}{k} \sum_{i=d}^n l_i \left[p_m(d_m')\right]^i \left[1 - p_m(d_m')\right]^{n-i}$$

with $l_i$ counting the number of malignant (error-inducing) patterns of weight $i$ among the $n$ encoded measurements.

A complementary timing formula for executing an encoded Pauli product (PP) set:

$$T_{\text{new}} = \frac{n \cdot (d_m' + 1)}{1 - p_D}$$

where $p_D$ is the detection failure probability for the code (i.e., the chance a detected error triggers a repeat of the block).

4. Hybrid Strategies: Time-Like Soft Information and TELS

Recent advances integrate time-like soft information—an inference about logical error likelihood from syndrome decoder reliability—into the TELS framework, further reducing runtime (Akahoshi et al., 24 Oct 2025). In "time-like soft information" protocols, one performs lattice surgery with a shortened syndrome window ($L < d$ cycles), evaluates the decoder's "gap" $g = |\Delta_t|$ between competing correction outcomes, and only reruns the measurement (now with the full $d$ cycles) if $g < g_\mathrm{th}$, a reliability threshold.

For a single Pauli measurement, this process offers no additional qubit or scheduling overhead: if $g \geq g_\mathrm{th}$, the fast result is accepted; otherwise, a full-length measurement is performed. Optimally, the error probability is unchanged and the average runtime is reduced (e.g., to $L + T_\mathrm{reaction}$ for the majority of runs), achieving a 32% reduction in example studies (for $p=10^{-3}$, $d=25$, $L=13$) (Akahoshi et al., 24 Oct 2025). The probability of a time-like logical error conditional on $g$ is

$P(\mathcal{T}|g) = \frac{1}{1 + e^{a g}}$

with $a \approx 0.9273$ (gap measured in dB).

For multiple simultaneous measurements, TELS (using classical codes) or hybrid "STELS" (soft-information-accelerated TELS) methods outperform either approach alone, especially as the measurement set size $k$ increases. In the combined STELS protocol, all Pauli measurements are first attempted with reduced rounds and soft information screening, with selective remeasurement (not always at full $d$) and final code decoding, thereby exceeding a 50% reduction in average runtime compared to serial protocols (Akahoshi et al., 24 Oct 2025).

5. Space–Time Trade-offs and Layout Optimization

TELS delivers a reduction in both runtime and space-time cost, which is critical for scaling practical surface code quantum computers (Prabhu et al., 2022, Chamberland et al., 2021, Fowler et al., 2018). Standard operations with $d$ syndrome rounds per measurement are "compressed" temporally, with qubit occupation per patch per logical operation reduced by a factor approaching $d/d_m'$ (with $d_m' \ll d$). In a magic-state factory or surface code data block, this translates directly into a smaller space-time volume per distilled magic state or Pauli measurement.

Further architectural improvements are obtained by matching surface code dimensions to physical noise bias (e.g., $d_z \gg d_x$ for dephasing-dominated noise), and by introducing a "core-cache" processor layout in which only patches engaged in active TELS operations occupy the high-throughput "core," with dense storage in a cache (Chamberland et al., 2021). The routing space overhead per unit cell is reduced to $(3/2) + (3/4)(d_x/d_z)$, lowering the multiplicative cost compared to previously proposed layouts.

6. Scheduling, Compiler Integration, and Theoretical Considerations

The practical application of TELS depends on efficient mapping, scheduling, and resource allocation in code compilers (LeBlond et al., 2023, Robertson et al., 5 Jun 2025, Hamada et al., 29 Jan 2024). Modern pipelines structure the logical circuit to identify parallelizable Pauli measurement sets, encode their outcomes using TELS, and schedule the resulting operations in space and time to minimize bottlenecks (including magic state production/consumption load-balancing). The resource estimation pipeline computes the minimum number of necessary magic state factories and storage, smoothing variable consumption rates by temporally encoding operations and optimizing per-layer throughput.

The theoretical optimization of spatial and temporal lattices for TELS is NP-hard (Herr et al., 2017), necessitating heuristic or approximate scheduling (e.g., graph-embedding, wave pipeline, or Dijkstra-based methods) to allocate local lattice-surgery instructions to physical hardware tiles while avoiding resource contention and maximizing parallelism (Hamada et al., 29 Jan 2024).

7. Impact and Practical Implications for Fault-Tolerant Quantum Computing

Temporally Encoded Lattice Surgery enables a continuous trade-off between error rates, resource overhead, and algorithm runtime. In particular, for algorithms with high $T$-gate count (e.g., $>10^8$), TELS combined with magic-state distillation and optimized scheduling offers dramatic reductions in the required number of physical qubits (down to $\sim\! 10^5$–$10^6$ in some use cases) and in wall-clock runtime (by factors up to $2$–$4$ per current benchmarks). TELS also enables the integration of Pauli product measurement routines, state injection protocols, and compiler design into a unified, scalable framework compatible with two-dimensional, nearest-neighbor hardware architectures.

Combined with experimental advances in superconducting and trapped-ion platforms using code deformations and lattice-surgery primitives, TELS presents a scalable pathway for realizing universal, resource-efficient, and high-throughput fault-tolerant quantum computation.