Spacetime codes introduce performance metrics tailored to their circuit-centric, heuristic approach, differing from traditional quantum error-correcting codes (QECCs) in key ways:

Key Performance Metrics for Spacetime Codes¶

Sampling Overhead
Spacetime codes prioritize minimizing the number of additional samples needed to achieve accurate results. For example, they achieve quartically lower sampling overhead compared to probabilistic error cancellation (PEC) by discarding fewer shots through targeted error detection.
Qubit and Gate Overhead
These codes use far fewer qubits and gates than full error correction. Experiments on IBM Heron processors demonstrated error detection in 50-qubit circuits with 2450 CZ gates, requiring only ~10% additional qubits. This contrasts with surface codes, which scale quadratically in qubit overhead with code distance.
Postselection Rate
The fraction of retained samples after error detection. Spacetime codes achieve postselection rates down to 10⁻³ while maintaining logical fidelity gains of up to 5× over uncorrected results. This metric balances error suppression against computational throughput.
Logical Fidelity Gain
Defined as the ratio of postselected logical state fidelity to raw physical fidelity. Experiments showed fidelity improvements of 2–5× for stabilizer states, certified via randomized measurement techniques.
Check Efficiency
The ability to design low-weight checks (e.g., weight-4 stabilizers) that cover large circuit regions while respecting hardware connectivity constraints. Algorithms optimize checks to detect errors across spacetime volumes rather than spatial slices.

Contrast with Traditional QEC Metrics¶

Metric	Traditional QECCs (e.g., Surface Codes)	Spacetime Codes
Primary Goal	Guaranteed error correction	Heuristic error detection
Overhead Scaling	Quadratic in code distance	Sublinear in circuit size
Threshold Focus	Code distance and pseudothreshold calculations	Postselection vs. fidelity tradeoffs
Gate Restrictions	Require Clifford+T decomposition	Native Clifford circuit support
Error Model	Symmetric Pauli channels	Arbitrary circuit-level noise

These metrics reflect spacetime codes' design for near-term applicability-they sacrifice theoretical guarantees for practical error suppression in complex circuits, unlike traditional QECCs that prioritize asymptotic fault tolerance. The framework enables single-shot fidelity certification through spacetime-folding techniques, a capability absent in conventional error mitigation approaches.

some older infos¶

Spacetime codes and spacetime circuits represent a circuit-centric approach to quantum error detection and correction, leveraging the intrinsic structure of Clifford circuits to construct stabilizer codes that map circuit faults to decodable errors. These frameworks prioritize low qubit/gate overhead and postselection efficiency, making them suitable for near-term quantum devices. In contrast, quantum data-syndrome (QDS) codes address correlated errors in both data qubits and syndrome measurements through redundant stabilizer checks, offering robustness against faulty syndrome extraction-a critical limitation in conventional error correction. While spacetime codes excel in heuristic error suppression for Clifford-dominated circuits, QDS codes provide systematic protection for general stabilizer codes at the cost of increased measurement complexity. Recent advances demonstrate spacetime codes achieving >200× fidelity gains in 50-qubit experiments and QDS codes enabling belief propagation decoding under phenomenological noise with 3% error thresholds, highlighting complementary roles in the quantum error correction landscape.

Spacetime Codes and Circuits: Circuit-Centric Error Correction¶

Definition and Construction¶

Spacetime codes are stabilizer codes derived from the outcome code of a Clifford circuit-the linear space of possible measurement outcomes generated by the circuit's stabilizer measurements. For an \(n\)-qubit circuit of depth \(\Delta\) with \(m\) measurements, the outcome code is an \([m, k]\) classical linear code, where \(k = n(\Delta + 1) - (m - k)\). The corresponding spacetime code is a stabilizer code with parameters \([[n(\Delta + 1), n(\Delta + 1) - (m - k)]]\), where logical operators correspond to circuit faults.

Key construction steps include:

Outcome Code Identification: The set of syndrome bit-strings forms a linear code under modulo-2 arithmetic.
Stabilizer Mapping: Checks of the spacetime code are derived by back-propagating outcome code parity checks through the circuit's inverse operations.
Low-Weight Check Optimization: Algorithms generate checks with weight \(\leq 4\) while respecting hardware connectivity, enabling LDPC code properties.

Performance Metrics¶

Sampling Overhead: Reduces quadratically compared to probabilistic error cancellation (PEC) by retaining \(10^{-3}\) of shots via targeted postselection.
Logical Fidelity Gain: Achieves 2–5× fidelity improvements in IBM Heron experiments through spacetime code postselection.
Check Efficiency: Weight-4 checks cover 85% of circuit spacetime volume in 50-qubit circuits, detecting errors across 2450 CZ gates.

Experimental Validation¶

Recent implementations on 50-qubit circuits demonstrate:

Physical-to-Logical Fidelity Gain: Up to 236× improvement using spacetime code postselection.
Overhead Scaling: Sublinear in circuit size-10% additional qubits for 50-qubit circuits vs. quadratic scaling in surface codes.

Quantum Data-Syndrome Codes: Protecting Measurements¶

Code Architecture¶

QDS codes augment stabilizer codes with syndrome measurement redundancy to correct both data errors (\(E \in \mathcal{G}_N\)) and syndrome bit-flips (\(e \in \{0,1\}^M\)). The extended check matrix becomes:

\[ \tilde{S} = \begin{bmatrix} S & I_M \\ 0 & A^T & I_r \end{bmatrix} \]

where \(A\) is the parity-check matrix of a classical \([m + r, m]\) syndrome measurement code. This allows syndrome errors to be detected as parity violations in the redundant checks.

Decoding and Bounds¶

Belief Propagation (BP) Decoding: Handles phenomenological noise by modeling mixed quaternary (Pauli) and binary (syndrome) errors on a Tanner graph. Achieves 3% threshold for rotated toric codes under 63μs decoder latency.
Singleton Bound: For an \([[n, k, d]]\) QDS code, \(n - k \geq 2(d - 1) + r\), where \(r\) is syndrome redundancy.
Hamming-Type Bound: Single-error-correcting QDS codes require \(3n + 3m \leq 2^{n + m - k - r - 1}\).

Subsystem Variants¶

QDS subsystem codes improve efficiency by separating gauge operators for data and syndrome errors:

\[ \mathcal{G} = \langle \mathcal{G}_{\text{data}}, \mathcal{G}_{\text{synd}} \rangle \]

This reduces the number of stabilizer measurements by 30% compared to stabilizer QDS codes while maintaining equivalent distance.

Comparative Analysis: Spacetime vs. Data-Syndrome Codes¶

Error Model Compatibility¶

Aspect	Spacetime Codes	Data-Syndrome Codes
Target Errors	Circuit-level Pauli faults in Clifford circuits	Data Pauli errors + syndrome bit-flips
Non-Clifford Gates	Exponential check space reduction	Compatible via concatenation
Correlated Errors	Detects spatially/temporally linked faults	Corrects up to \(t\) combined data/syndrome errors

Resource Overhead¶

Qubits: Spacetime codes add \(O(n\Delta)\) qubits vs. \(O(m + r)\) for QDS.
Measurements: QDS requires \(m + r\) checks vs. spacetime's \(m\) native checks.
Decoding Complexity: Spacetime uses standard stabilizer decoders, while QDS requires augmented BP.

Performance Trade-offs¶

Metric	Spacetime Codes Advantage	QDS Codes Advantage
Sampling Efficiency	Postselection retains 0.1% shots with 5× fidelity	No postselection needed
Syndrome Robustness	Limited to native circuit checks	Corrects \(t\)-bit syndrome errors
Universality	Optimized for Clifford circuits	Applies to any stabilizer code

Recent Advances and Future Directions¶

Spacetime Code Developments¶

Low-Overhead Detection: 2025 experiments demonstrate 50-qubit circuits with 2450 CZ gates achieving 236× fidelity gain using weight-4 checks.
Universal Circuit Support: Checks remain findable for 10% non-Clifford gates, but success probability drops exponentially with T-gate count.

QDS Innovations¶

Phenomenological Decoding: BP decoders handle 1.1μs cycle times with 63μs latency, sustaining performance over \(10^6\) cycles.
Single-Shot QDS: Constructed from cyclic codes (e.g., Steane code), enabling fault tolerance with 2× syndrome redundancy.

Open Challenges¶

Spacetime Code Scalability: Maintaining LDPC properties for 1000+ qubit circuits remains unproven.
QDS Code Rates: Achieving rates >0.5 while satisfying Singleton bounds requires new classical code constructions.
Hybrid Approaches: Combining spacetime checks with QDS redundancy could mitigate correlated errors in fault-tolerant circuits.

Spacetime codes and data-syndrome codes address distinct facets of quantum error correction-circuit-level fault detection and syndrome reliability, respectively. While spacetime codes offer near-term applicability through low-overhead postselection, QDS codes provide foundational protection against measurement errors critical for long-term fault tolerance. The 2025 experimental milestone of spacetime codes achieving >200× fidelity gains underscores their potential for pre-threshold quantum advantage, whereas QDS advancements in BP decoding highlight a path toward robust syndrome extraction. Future work may integrate these paradigms, leveraging spacetime's circuit adaptability with QDS's measurement redundancy to achieve comprehensive error suppression in scalable quantum systems.

Spacetime Codes and Spacetime Circuits¶

Core Idea: Spacetime codes are a recent framework that treats a quantum circuit itself as a code by combining spatial and temporal degrees of freedom.
Mechanism (Clifford Circuits):
- Given a quantum circuit (particularly Clifford), one can derive a corresponding stabilizer code that enforces the expected behavior of that circuit.
- Key observation (Delfosse and Paetznick, 2023): the set of all possible measurement outcome bit-strings of a fault-free Clifford circuit forms a linear classical code (called the outcome code).
- Any deviation from these allowed outcomes indicates that faults (errors) have occurred.
Spacetime Code Construction:
- From the outcome code, one constructs a quantum stabilizer code – the spacetime code.
- Its stabilizer generators (also called detectors) are designed to detect deviations from the outcome code.
- Each stabilizer checks a parity relation among measurement outcomes (and potentially data qubits) that must hold if the circuit is fault-free.
- If a fault (gate error, bad measurement) occurs, one or more stabilizers are violated, flagging an error in space or time.

Formal Construction:

Process: Involves mapping the circuit’s structure to stabilizers.
Clifford Circuits:
- Algorithmically derive the outcome code (binary linear code).
- Treat each parity-check of the outcome code as a stabilizer on corresponding qubits in an enlarged Hilbert space.
Enlarged Space: Typically includes original data qubits plus ancilla qubits representing measurement outcomes at various timesteps.
Example:
- If a circuit yields \(m\) binary outcomes, the outcome code has a parity-check matrix \(H\) (size \(r\times m\)).
- Each row of \(H\) corresponds to a parity constraint.
- The spacetime stabilizer code includes a generator (often \(Z\)-type on ancillas) enforcing each parity check.
Additional Constraints: Data qubit evolution under gates imposes its own constraints (e.g., Bacon et al. used gauge operators for input-output relations).
Resulting Code: Usually a stabilizer code (often a subsystem code with gauge operators), whose stabilizers intertwine spatial and temporal degrees of freedom.

Stabilizers as Detectors:

Intuition: A spacetime stabilizer (“detector”) might compare outcomes at different times or locations to detect inconsistencies caused by faults.
Example (Repeated Measurements):
- In a fault-tolerant syndrome extraction circuit repeated over time, a natural spacetime stabilizer is the parity of a syndrome bit across two consecutive rounds.
- If no fault occurs (and no data error between rounds), the syndrome should be the same; a flip indicates a fault.
Surface Code Connection: This is exactly how repeated syndrome measurements are decoded in surface codes: pairs of successive measurements are checked, forming a detector. These parity checks are stabilizer generators spanning two time steps.
Generalization: Any Clifford circuit’s fault-tolerant structure yields such detectors. Stabilizer generators are often called detector checks.

Fault-Tolerance Properties:

Encapsulation: The spacetime code encapsulates the fault-tolerance of the original circuit.
Fault Manifestation: \(t\) independent faults (gate errors, bad measurements) manifest as \(\le t\) error events in the spacetime code picture – a weight-\(t\) Pauli error on spacetime code qubits (ancilla outcome flips represent measurement errors).
Correction Capability: If the spacetime code has distance \(d\), it can detect/correct faults up to weight \(\lfloor (d-1)/2\rfloor\).
Equivalence: Correcting errors in the spacetime stabilizer code is equivalent to decoding faults in the circuit.
Performance Link: Delfosse and Paetznick proved a maximum-likelihood decoder for the spacetime code transforms into a maximum-likelihood fault decoder for the circuit.
Implication: Error-correction performance (logical error rate vs. physical error \(p\)) of the spacetime code directly reflects the circuit's fault-tolerance.

Decoding Spacetime Codes:

Leveraging Classical Coding: Since the outcome code for Clifford circuits is linear, efficient classical decoding algorithms can be used.
Graphical Decoding: Decoding often becomes a graphical problem, similar to standard QEC.
- Detector violations (syndrome) are mapped onto a graph (e.g., 3D for space + time).
- Algorithms like minimum-weight matching identify the most likely fault chain.
Example: Surface Code: Repeated syndrome measurements in surface codes create a 3D lattice; decoding involves pairing detection events in this spacetime structure.
Automated Tools: Software like Stim can automatically generate a detector graph (Tanner graph of checks) from a Clifford circuit.
Circuit-Centric Approach: Spacetime decoding considers both spatial and temporal error correlations, incorporating circuit dynamics directly into the code structure, unlike static code approaches.

Overhead and Clifford Limitations:

Ancilla Overhead:
- Intermediate measurement outcomes are treated as effective ancilla qubits in the spacetime code formalism.
- Circuits with many measurements increase the formal size of the spacetime code (data qubits + outcome ancillas).
Check Weight Overhead:
- Naive construction can lead to high-weight stabilizers (checks involving many qubits/times), which are hard to implement.
Optimization:
- A key advantage is the ability to optimize checks to be low-weight and sparse.
- Bacon et al. (2017) showed how to convert Clifford circuits into sparse subsystem codes using ancillas.
- Delfosse & Paetznick (2023) provided algorithms for identifying and generating LDPC (low-density parity-check) spacetime codes, enabling efficient decoding.
Geometric Locality: Optimized spacetime codes can sometimes be made geometrically local, potentially allowing physical realization.
Theoretical Tool vs. Implementation: Currently, spacetime codes are primarily a theoretical/decoding tool, though the line blurs (e.g., using a derived spacetime code as an error-detecting gadget).
Clifford Circuit Reliance:
- The direct circuit-to-code mapping works elegantly for Clifford circuits (Pauli errors map to Pauli errors, linear outcome dependence).
- Non-Clifford gates break this linearity, making the outcome set non-linear or state-dependent.
Handling Non-Clifford Gates:
- Applicable to Clifford-dominated circuits.
- Non-Clifford parts might be handled via gadgetization or ignored for error detection.
- Research indicates valid spacetime checks decrease exponentially with non-Cliffordness.
Current Scope: Most effective for circuits largely composed of Clifford gates (e.g., stabilizer measurements, specific algorithms). Extending to general non-Clifford circuits is an active research area.

Example (Repetition in Time):

Scenario: Protecting a single qubit from \(X\) errors using three repeated \(Z\)-basis measurements.
Outcomes: Three bits \((s_1, s_2, s_3)\).
Fault-Free Behavior: Outcomes should be identical (e.g., 000 or 111), forming a classical \((3,1,3)\) repetition code. Deviations (010, 001) indicate faults.
Parity Checks: The outcome code has checks \(s_1 \oplus s_2 = 0\) and \(s_2 \oplus s_3 = 0\).
Spacetime Code: A stabilizer code on three conceptual ancillas (representing the qubit state at each measurement time) with stabilizers \(Z_1 Z_2\) and \(Z_2 Z_3\).
Error Correction: This distance-3 code detects/corrects one measurement error. E.g., if \(s_2\) flips (010), both checks are violated, pinpointing \(s_2\).
Generalization: Complex circuits yield more elaborate outcome codes, but the principle (redundancy in time detects errors) remains. Detector decoders use spacetime graphs to find error chains.

Applications:

General Paradigm: Applicable from full error correction to near-term error detection.
Postselection: Add ancilla-driven spacetime checks to detect errors; discard faulty runs.
- Recent work demonstrated low-overhead checks significantly boosting fidelity via postselection, guided by the spacetime framework for feasible (low-weight, local) and effective checks.
Decoding Automation: Tools like Stim automatically generate detector graphs from circuits, enabling automated fault decoder generation for complex QEC circuits.
Space-Time Tradeoffs: Illuminating research into strategies like spacetime concatenation (concatenating codes temporally).
Unified Framework: Provides a rigorous way to view fault-tolerant circuits as codes, importing classical coding theory and decoding techniques.

Quantum Data-Syndrome (QDS) Codes¶

Approach: Quantum data-syndrome codes take a more traditional coding-theoretic approach to measurement errors.
Core Idea: A QDS code is essentially a stabilizer code augmented with extra redundancy in its stabilizer measurements.
Goal: Allows correction of both data qubit errors and syndrome bit flips together.
Mechanism: Typically concatenates a quantum code (protecting data) with a classical code (protecting syndrome bits).
Objective: Ensure the global syndrome record can be interpreted correctly even with faulty measurements.

Basic Idea:

Standard QEC: Measure \(m = n-k\) independent stabilizers for an \([[n,k]]\) code to get a syndrome. Incorrect measurements can mislead the decoder.
QDS Solution: Addresses this by not relying on single shots of syndrome bits.
Redundancy: Introduces redundancy such that the set of possible syndrome outcomes from a QDS code (with no faults) is constrained.
Methods: Often done by measuring additional stabilizers or repeating measurements (e.g., measure each stabilizer twice/thrice). Linear combinations can also be used as extra checks.
Function: Extra measurements provide cross-checks for corrupted syndrome values (redundant for data error info if fault-free).
Syndrome Code: The syndrome bits themselves form a small error-correcting code.
Concise Definition (Error Correction Zoo): QDS codes are stabilizer codes whose generators encode extra redundancy (via a linear binary code) to protect against syndrome measurement errors.
Name Origin: "Data-syndrome" reflects that the codeword encompasses both data qubits and syndrome bits.

Formal Definition:

Specification: Defined by specifying a stabilizer group with a certain generating set.
Construction:
- Start with a base stabilizer code \(Q\) (generators \({g_1,\dots,g_m}\)).
- Effectively add \(r\) additional redundant stabilizer measurements (re-measurements or products).
- Yields \(m+r\) total measurements.
Constraint: These \(m+r\) outcomes satisfy constraints if no errors occurred.
Equivalence: There's a binary linear code \(C\) (length \(m+r\)) that these bits lie in during an error-free run.
Classical Code \(C\): Typically a classical \([m+r, m]\) code encoding the original \(m\) syndrome bits into \(m+r\) bits (adding \(r\) checks), implemented physically.
- Example: If \(C\) has parity-check matrix \(H_C\), add \(r\) measurements obtaining the syndrome encoded plus parity checks from \(H_C\).
- Simplest Case: Repetition code on each syndrome bit.
Joint System: The joint data-plus-syndrome system behaves like an \([[n + \text{(ancillas)} , k, d]]\) code correcting combined errors.
Combined Code: Rigorously defined via \(C_{\text{DS}}\subset \mathbb{F}_4^n \times \mathbb{F}_2^{m}\) encoding stabilizer and redundant syndrome info.
QDS Distance \(d\): Minimum weight of any combined error \((e,z)\) in the forbidden subspace (excluding trivial ones).
Correction Capability: A QDS code of distance \(d\) corrects errors if total weight \(t_D + t_S < d/2\).
Analogy: Extends the usual quantum code condition to include syndrome flips.
Summary: Turns syndrome errors + data errors into one coding problem on a larger alphabet (often phrased as concatenating binary + quaternary codes).

Example & Redundancy Patterns:

Simplest QDS: Repeated syndrome measurement (original Shor FT approach).
- Repeating extraction \(\ell\) times effectively uses a length-\(\ell\) repetition code on each syndrome bit independently.
- Example: Measuring thrice uses a \((3,1,3)\) repetition code per bit, correcting one flip.
Beyond Repetition: QDS generalizes this, allowing cleverer syndrome encoding.
- Fujiwara et al.: Specific generator choices for Steane [[7,1,3]] or Golay [[23,1,7]] codes give built-in redundancy against one measurement error without literal repetition.
Syndrome Measurement (SM) Codes (Ashikhmin et al. 2020):
- Use a classical linear block code to encode \(m\) syndrome bits into \(m+r\) bits, implemented via additional stabilizer measurements.
- Potentially more efficient than repeating each bit \(\ell\) times (\(m\cdot(\ell-1)\) extra bits). An \([m+r, m, d_c]\) code might correct \(t\) flips with fewer than \(m(t)\) extra bits.
- Generalizes repetition, achieving better syndrome decoding. Correlated extra measurements allow detectable patterns.
Illustration (2 Stabilizers):
- Stabilizers \(g_1, g_2\), syndromes \((s_1,s_2)\).
- Naive QDS: Repeat \(\rightarrow (s_{1,1}, s_{1,2}), (s_{2,1}, s_{2,2})\). Expect pairs match.
- Clever QDS: Measure \(g_1 g_2\) for \(s_3\). Ideally \(s_3 = s_1 \oplus s_2\). If \(s_1\) or \(s_2\) flips, \(s_3\) is inconsistent, detecting an issue.
- This uses a \([3,2,2]\) classical code (2 info, 1 parity) for the syndrome.
Concatenated View: QDS often resembles concatenation: Classical \([m+r, m, d_c]\) code (syndromes) + Quantum \([[n,k,d_q]]\) code (data).
- Corrects roughly \(\lfloor(d_q-1)/2\rfloor\) data errors and \(\lfloor(d_c-1)/2\rfloor\) measurement errors (subject to joint distance \(d\)).

Decoding Strategies:

Conceptual Two Stages: Often occurs in two steps: first decode syndrome-bit error, then data error.
Process:
1. Apply classical decoder to \(m+r\) outcomes to estimate "true syndrome".
2. Feed reliable syndrome into quantum decoder for data code.
Rationale: Natural for concatenated structure; often optimal/near-optimal if measurement errors are rare.
Joint Decoding:
- Possible in principle: Use generalized algorithm on combined code (e.g., treat as one stabilizer code in \(\mathbb{F}_4^n \times \mathbb{F}_2^m\)).
- Potential Benefit: Marginally better performance if errors correlated.
- Drawback: Computationally more complex.
Practical Assumption: Measurement errors often independent, making separate classical decoding effective.

Fault-Tolerance and Distance:

Enhancement: QDS enhances fault tolerance by increasing faults tolerated per round.
Baseline Problem: Plain [[n,k,d]] code: single syndrome flip can cause logical error if decoder misled (why standard FT repeats measurements).
QDS Benefit: Distance \(d'\) code corrects up to \(\lfloor(d'-1)/2\rfloor\) syndrome flips (or combined errors).
Example: Fujiwara (2014): Clever generator choice makes Steane code [[7,1,3]] tolerate one syndrome error automatically.
Trade-offs: Cannot arbitrarily increase measurement FT without increasing code size; QDS codes obey bounds.
Bounds: Analogues of Singleton and Hamming bounds derived.
- QDS Singleton bound: Roughly \(n + (m+r) - 2d + 2 \ge 0\).
Random QDS Codes: Studies show performance near quantum GV bound even with small \(r\). Suggests efficiency: little redundancy goes far.

Overhead Considerations:

Forms: Usually additional measurements and ancilla qubits, potentially longer time (sequential repeats).
Time Overhead: \(\ell\) rounds multiply cycle time by \(\ell\). Can reduce effective rate or increase idle errors if measurement is slow.
Parallel Measurement: Alternative QDS proposals measure redundant stabilizers in parallel. May need more ancillas or complex circuits (e.g., measuring products). Can increase depth/error sources.
Trade-off: Gain tolerance to measurement errors at the price of more resources.
Practical Redundancy: \(r\) often doesn't need to be large. Single extra round (\(r=m\)) or small \(r\) (2-3 parity bits) can significantly suppress errors.
Reducing Overhead (Recent Work):
- Subsystem QDS Codes (Nemec 2023): Use gauge qubits. Some redundancy treated as gauge operators (detect errors, no new logical constraints). Allows gauge fixing for simpler recovery.
- Impure QDS Codes (Nemec 2023): Don't detect all weight-\(<d\) errors but still correct with high probability (trade strict distance). More exotic.
Gate Overhead: Each extra stabilizer measured adds gates (CNOTs), slightly increasing data error chance during extraction. Balance needed. Optimal overhead depends on physical error rates.