Pith. sign in

REVIEW 3 major objections 4 minor 38 references

Deterministic Fault-Tolerant State Preparation for Near-Term Quantum Error Correction: Automatic Synthesis Using Boolean Satisfiability

T0 review · 3 major / 4 minor · reviewed 2026-08-10 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Satisfiability solving turns repeat-until-success state preparation into a deterministic, fault-tolerant protocol.

desk verdict Genuinely useful automation for fault-tolerant state preparation on small CSS codes, with a real but fixable gap in the formal guarantee for faults inside the correction circuit. read the letter →

arxiv 2501.05527 v1 pith:PVZQYME5 submitted 2025-01-09 quant-ph

Ludwig Schmid , Tom Peham , Lucas Berent , Markus Müller , Robert Wille This is my paper · ORCID
classification quant-ph
keywords quantumerrorcorrectionfault-tolerantstatepreparationCSScodesBooleansatisfiabilitycircuitsynthesisnear-termhardwarerepeat-until-successlogicalinitialization
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper claims that the final obstacle to deterministic fault-tolerant state preparation for small CSS codes can be eliminated automatically. Given a non-deterministic preparation circuit, whose verification can detect but not fix dangerous errors, the authors synthesize a correction circuit that turns the whole procedure into a single-shot protocol, without post-selection or repeat-until-success. The search for the additional stabilizer measurements and the conditional recovery is encoded as a Boolean satisfiability problem and solved to optimality, minimizing both the number of measurements and the CNOT weight of the correction. If the claim holds, it removes a practical synchronization and time-overhead problem for near-term quantum hardware that encodes qubits in [[n,k,d]] CSS codes with $d < 5$. The paper supports the claim with circuit-level noise simulations showing that logical error rates scale quadratically in the physical error rate.

What carries the argument

The load-bearing object is the syndrome partition of dangerous errors: errors from a single fault in preparation are grouped by the verification syndrome $b$ into sets $E_b$, and the correction circuit is a list of additional stabilizer measurements that splits each $E_b$ until every resulting class has a common recovery Pauli. The synthesis task, called CORRECTION CIRCUIT SYNTHESIS, is a decision problem asking whether $u$ stabilizer measurements of total weight at most $v$ can achieve this splitting, and it is solved by iterating over $u$ and $v$ with a Boolean satisfiability solver to obtain an optimum. For hook errors, the flag-qubit syndrome $f$ is appended to $b$ before the partition, so the same machinery makes the flag-based verification deterministic rather than repeat-until-success.

What would settle it

Run the deterministic protocol under circuit-level depolarizing noise and inject a single Pauli fault on a CNOT inside one of the synthesized correction measurements, then decode the final state. If any such single fault produces a final data error of weight two or more that no later step detects, the deterministic fault-tolerance claim fails. Concretely, the error sets $E_b$ would need to be redefined to include the images of correction-circuit faults, and the SAT instance would have to be re-solved; a circuit with all such faults included in the verification would be the positive counterpart.

Watch

Extended reading notes

Core claim

The central claim is that any non-deterministic fault-tolerant state preparation for an [[n,k,d]] CSS code with $d < 5$ can be extended into a deterministic one by appending a correction circuit, while preserving strict fault-tolerance. The construction goes through the syndrome structure: for each syndrome $b$ of the verification measurements, the set of dangerous errors $E_b$ is further partitioned by additional stabilizer measurements until all errors in a class share a single recovery Pauli $c_b$; executing $c_b$ leaves at most a weight-one error. Hook errors, which arise when a fault in a verification measurement spreads to the data, are handled by flag qubits whose syndrome is fed into the same partition. The paper establishes that the synthesized correction circuits are optimal in the number of additional measurements and in the summed CNOT weight, and it reports globally optimized verification-plus-correction circuits for nine near-term codes, including the Steane, Shor, surface, and tesseract codes.

Load-bearing premise

The protocol is guaranteed fault-tolerant only if a fault inside the newly added correction circuit cannot spread into an undetectable weight-two data error; the paper's formal error model explicitly covers single-qubit and measurement errors in the correction stage, while the safety of correction-circuit CNOT faults is checked by simulation rather than by the synthesis condition.

Editorial extensions

If this is right

  • Any existing non-deterministic repeat-until-success state preparation for a $d < 5$ CSS code can be converted into a deterministic protocol with a guaranteed, fixed execution depth per run.
  • For a fixed verification circuit, the appended correction is optimal in measurement count and CNOT weight, so no smaller correction exists for that verification.
  • When the global optimization is run, the resulting verification-plus-correction pair is the smallest among all minimal verification circuits, which the table shows can beat the hand-crafted construction for the Shor and [[11,1,3]] codes.
  • The synthesized circuits achieve logical error rates $O(p^2)$ for $d < 5$ codes, meaning two independent physical errors are required for a logical error, as required by strict fault-tolerance.
  • The open-source implementation lets a user generate deterministic state preparation for a new small CSS code without manual analysis.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The same SAT formulation could be extended to distance-five codes if the correction circuit itself were made fault-tolerant, since the current $d < 5$ assumption keeps single-fault and hook-fault cases mutually exclusive.
  • A natural tightening of the method would be to add the correction-circuit CNOT faults into the error sets $E_b$ explicitly; this would turn the numerical fault-tolerance check into a formal guarantee.
  • Because the correction search depends only on the stabilizer structure, the technique could be composed with any verification synthesis approach, such as reinforcement-learning methods, to scale to larger codes without hand derivation.
  • On real hardware the protocol should show a fixed latency distribution rather than the heavy-tailed runtime of repeat-until-success, which is a directly testable signature of the deterministic procedure.
Share X Bluesky LinkedIn Reddit HN

Formalized claims in Lean

  1. Claim #1: The paper's main theorem: every non-deterministic fault-tolerant state preparation for a CSS code of distance < 5 can be extended by a correction circuit to a fault-tolerant procedure, with the correction circuit optimal in the number/weight of additional measurements and in CNOT weight.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 4 minor

Summary. The paper addresses deterministic fault-tolerant initialization of encoded logical states for small CSS codes. It builds on non-deterministic repeat-until-success state preparation: a generally non-fault-tolerant preparation circuit followed by verification. Given such a preparation and verification for an [[n,k,d]] CSS code with d<5, the authors formulate the synthesis of a correction circuit—additional stabilizer measurements followed by Pauli recovery—as a Boolean satisfiability problem. By iterating over the number of measurements and their weights, the correction circuit is claimed optimal in measurement count and CNOT weight. The protocol treats X and Z layers separately, uses flag qubits for hook errors in the verification measurements, and optionally globally optimizes verification and correction together. The paper reports circuit metrics for nine codes and validates the circuits by Dynamic Subset Sampling circuit-level noise simulations showing quadratic logical-error scaling, with code available as part of MQT.

Significance. If the central theorem were fully established, this would be a useful design-automation contribution: it replaces manual, code-specific constructions of deterministic fault-tolerant state preparation with a SAT-based search that gives per-branch optimality guarantees, and it ships open-source software. The DSS simulations provide strong empirical evidence that the generated circuits have no linear-error term for the tested depolarizing model, and the table of circuit metrics allows direct comparison with prior hand-crafted circuits. The paper is clearly written and the treatment of hook errors in verification via flag qubits is a sound and practical idea. The main gap concerns the fault model for the newly added correction measurements, which prevents the theorem as stated from being established.

major comments (3)
  1. [Section IV, 'CORRECTION CIRCUIT SYNTHESIS' and Section III-B] The error sets E_X(C) and E_Z(C) are built exclusively from single faults in the non-fault-tolerant preparation circuit C, together with single-qubit errors present when the correction is applied; there is no corresponding error set for faults inside the newly added correction measurements of step (d) in Fig. 3. A single Z fault on the ancilla between two CNOTs of a weight-four correction stabilizer measurement propagates to a weight-two data error, and a single X fault on that ancilla can flip the very measurement outcome used to choose the recovery. Neither event is constrained by the synthesis condition that every error in a syndrome class be reducible to weight at most one, so the theorem that the overall procedure is fault-tolerant according to Definition 1 is not proven. The DSS simulations in Section V-B are numerical evidence, not part of the guarantee; without either an argument that correction-measurement faults are covered by subsequent verification or an extension of the error model, the abstract's unconditional fault-tolerance claim should be weakened.
  2. [Section V-B, 'Simulation'] The simulation protocol appends a perfect round of error correction before the final destructive measurement. This means the reported logical error rate does not directly test the fault-tolerance condition of Definition 1, which concerns the weight of the error on the output state before any further correction. A single fault in a correction measurement could produce a weight-two error that is nevertheless corrected by the final perfect decoder, so the quadratic scaling of p_L is necessary but not sufficient evidence for the strict fault-tolerance claim. The paper should either state that the numerical validation targets logical failure probability rather than the strict weight condition, or it should directly inspect the output error weight before the final correction.
  3. [Section V-A, 'Circuit Generation', and abstract] The abstract and Section III-B claim that the synthesized correction circuits are guaranteed optimal, 'requiring as few CNOTs as possible.' However, Section V-A reports that the global optimization was canceled after two hours for the Carbon and [[16,2,4]] codes and explicitly describes the reported numbers as 'currently best-known circuits.' For those codes, exhaustive optimality is not established. The per-branch optimality for a fixed verification circuit is valid, but the global optimality claim must be qualified to the circuits actually explored, or the optimization must be run to completion with a documented runtime bound.
minor comments (4)
  1. [Section VI] The future-work sentence states that codes beyond distance four would require 'correct handling of two or more independent errors, i.e., also within the conditional correction circuits.' This phrasing suggests that correction-circuit faults are only a problem starting at d>=5, but a single fault inside a correction measurement already needs to be handled for d=3 and d=4, since Definition 1 with t=1 applies to the entire circuit including the correction part.
  2. [Section IV] The exact SAT encoding is not described in the paper but only referenced to the source code. A short appendix with the Boolean constraints or a correctness argument for the encoding would make the method self-contained and easier to verify.
  3. [Table I] The table is difficult to read because several entries are malformed, e.g., '0 .5 1 .5' and 'T etrahedal'; also 'Jn, k, dK' should be rendered as [[n,k,d]] for consistency with the text.
  4. [References] Reference [27] is a bare URL with no author or title; it should be replaced with a proper citation to the underlying public dataset or database.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity: the SAT-based correction synthesis and optimality search are self-contained; self-citations are tooling and prior protocols, not load-bearing.

full rationale

The paper's central derivation is the reduction of correction-circuit synthesis to a SAT decision problem over stabilizers, with optimality obtained by iterating u and v until a YES-instance is found and the smaller case is not (Section IV). This is a constructive search whose output is checked by the solver; no fitted parameter is renamed as a prediction. The fault-tolerance behavior is validated externally by circuit-level Dynamic Subset Sampling simulations under a standard depolarizing model (Section V-B), which are not fitted to the synthesis output. The paper does cite the authors' own prior work [17], [22], [36]; however, that work supplies the non-deterministic protocol, the verification-circuit synthesis tool, and the software toolkit, not the claimed correction-circuit result. The correction synthesis itself is independently encoded and verified. The skeptical concern that faults inside the newly added correction measurements are not included in the synthesis error model is a completeness gap in the formal proof, not a circular step: the conclusion is stronger than, rather than equivalent to, the stated assumptions. No step reduces by construction to its own input.

Assumptions & free parameters 2 free parameters · 4 assumptions · 0 invented entities

The method introduces no new physical entities. It reuses standard stabilizer codes, flag fault-tolerance, and Pauli recovery. The free parameters are design choices (flagging and runtime cutoff) rather than physical constants, and the key unstated assumption is the fault-tolerance of the correction circuit itself.

free parameters (2)
  • Flagging choice per stabilizer measurement = Not numerically specified; Boolean choices reported via am/af columns in Table I
    The decision to flag or not flag certain verification measurements is made per code to reduce overhead (Section IV: 'occasionally, it might be preferable not to flag certain stabilizer measurements'); it affects circuit metrics but not the core FT claim, which is validated by simulation.
  • Global optimization runtime cutoff = 2 hours
    The global optimization procedure was canceled after two hours for the Carbon and [[16,2,4]] codes (Section V-A), so the reported circuits for those codes are best-known rather than proven globally optimal.
assumptions (4)
  • standard math Stabilizer formalism and CSS code properties
    Used throughout Section II as background; the code space, stabilizer generators, and logical operators are standard stabilizer code theory.
  • domain assumption Strict fault-tolerance Definition 1
    Definition 1 (errors of probability order t propagate to weight at most t) is the adopted correctness criterion. It is a standard notion but a chosen definition, and the central claim is evaluated against it.
  • domain assumption At most one fault occurs in the whole protocol because d<5
    The entire correction synthesis assumes single-fault events (Section IV: 'Since we aim to protect the state preparation circuit against single errors (due to our assumption d<5)...'), which is justified for distance 3 and 4 codes with single-error correction.
  • ad hoc to paper Single faults inside the correction circuit either do not create weight-2 data errors or are captured by the syndrome used for recovery
    The text explicitly accounts for single-qubit errors and measurement errors in E_b, but does not prove that CNOT faults within the correction measurements are benign. The paper relies on simulation (Section V-B) for this property. If violated, the protocol could fail with O(p) logical errors.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Deterministic Fault-Tolerant State Preparation for Near-Term Quantum Error Correction: Automatic Synthesis Using Boolean Satisfiability." pith.science (2026). https://pith.science/paper/PVZQYME5

@misc{pith2026250105527,
  author       = {Pith},
  title        = {Pith review of: Deterministic Fault-Tolerant State Preparation for Near-Term Quantum Error Correction: Automatic Synthesis Using Boolean Satisfiability},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/PVZQYME5}},
  note         = {Machine review of arXiv:2501.05527}
}
read the original abstract

To ensure resilience against the unavoidable noise in quantum computers, quantum information needs to be encoded using an error-correcting code, and circuits must have a particular structure to be fault-tolerant. Compilation of fault-tolerant quantum circuits is thus inherently different from the non-fault-tolerant case. However, automated fault-tolerant compilation methods are widely underexplored, and most known constructions are obtained manually for specific codes only. In this work, we focus on the problem of automatically synthesizing fault-tolerant circuits for the deterministic initialization of an encoded state for a broad class of quantum codes that are realizable on current and near-term hardware. To this end, we utilize methods based on techniques from classical circuit design, such as satisfiability solving, resulting in tools for the synthesis of (optimal) fault-tolerant state preparation circuits for near-term quantum codes. We demonstrate the correct fault-tolerant behavior of the synthesized circuits using circuit-level noise simulations. We provide all routines as open-source software as part of the Munich Quantum Toolkit (MQT) at https://github.com/cda-tum/mqt-qecc.

Figures

Figures reproduced from arXiv: 2501.05527 by the authors.

Figure 1
Figure 1. Steane code with a hook error on a Z stabilizer. but are not in S and the code distance d of a stabilizer code is the weight of a minimal logical operator. When talking about errors in the context of stabilizer codes, we are usually only interested in minimal-weight stabilizer-equivalent representatives since we can multiply an error by a stabilizer without changing its effect. Therefore, for e ∈ Pn, we define wtS(e… view at source ↗
Figure 2
Figure 2. Deterministic fault-tolerant state preparation of the Steane code |0⟩L with error propagation and correction. second and third CNOT propagates to a weight-two error on the data qubits. In particular, CNOTs between data qubits often violate the requirement of strict fault-tolerance since single-qubit errors on the data propagate further. Therefore, circuits used to pre￾pare logical states are themselves not necessari… view at source ↗
Figure 3
Figure 3. Deterministic fault-tolerant state preparation protocol for [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: The logical error rates for the |0⟩L states of the heuristic state preparation and optimal verification from Table I. The global optimization, exploring all possible verification and correction circuits, yields equivalently good circuits in most cases. For the Carbon a…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

38 extracted references · 30 canonical work pages

  1. [17]

    Heußen et al

    S. Heußen et al. Strategies for a practical advantage of fault-tolerant circuit design in noisy trapped-ion quantum computers. Phys. Rev. A, 107(4), 2023

    work page 2023

  2. [1]

    Aharonov et al

    D. Aharonov et al. Fault-tolerant quantum computation with constant error. In Proc. Twenty-Ninth Annu. ACM Symp. Theory Comput. STOC ’97, pages 176–188, New York, NY , USA, 1997

    work page 1997

  3. [2]

    Bermudez et al

    A. Bermudez et al. Fault-tolerant protection of near- term trapped-ion topological qubits under realistic noise sources. Phys. Rev. A, 100(6):062307, 2019

    work page 2019

  4. [3]

    Bluvstein et al

    D. Bluvstein et al. Logical quantum processor based on reconfigurable atom arrays. Nature, 626(7997):58–65, 2024

    work page 2024

  5. [4]

    H. Bombin. An Introduction to Topological Quantum Codes, 2013. arXiv: 1311.0277

    arXiv 2013

  6. [5]

    Bombin et al

    H. Bombin et al. Optimal resources for topological two- dimensional stabilizer codes: Comparative study. Phys. Rev. A, 76(1):012305, 2007

    work page 2007

  7. [6]

    Butt et al

    F. Butt et al. Fault-Tolerant Code-Switching Protocols for Near-Term Quantum Processors. PRX Quantum , 5(2):020345, 2024

    work page 2024

  8. [7]

    A. R. Calderbank et al. Good quantum error-correcting codes exist. Phys. Rev. A, 54(2):1098–1105, 1996

    work page 1996

Show all 38 references
  1. [8]

    Chamberland et al

    C. Chamberland et al. Flag fault-tolerant error correc- tion with arbitrary distance codes. Quantum, 2:53, 2018

    2018

  2. [9]

    de Moura et al

    L. de Moura et al. Z3: An Efficient SMT Solver. In C. R. Ramakrishnan et al., editors, Tools and Algorithms for the Construction and Analysis of Systems , pages 337– 340, Berlin, Heidelberg. Springer, 2008

    2008

  3. [10]

    Dennis et al

    E. Dennis et al. Topological quantum memory. Journal of Mathematical Physics , 43(9):4452–4505, 2002

    2002

  4. [11]

    P.-J. H. S. Derks et al. Designing fault-tolerant circuits using detector error models, 2024. arXiv: 2407.13826

    2024

  5. [12]

    H. Goto. Minimizing resource overheads for fault- tolerant preparation of encoded states of the Steane code. Sci Rep, 6(1):19578, 2016

    2016

  6. [13]

    Gottesman

    D. Gottesman. Stabilizer codes and quantum error correction. PhD thesis, Caltech, 1997

    1997

  7. [14]

    Heußen et al

    S. Heußen et al. Dynamical subset sampling of quantum error-correcting protocols. Phys. Rev. Res., 6:013177, 1, 2024

    2024

  8. [15]

    Heußen et al

    S. Heußen et al. Efficient fault-tolerant code switching via one-way transversal CNOT gates, 2024. arXiv: 2409.13465

    2024 arXiv

  9. [16]

    Heußen et al

    S. Heußen et al. Measurement-Free Fault-Tolerant Quantum Error Correction in Near-Term Devices. PRX Quantum, 5(1):010333, 2024

    2024

  10. [18]

    A. Kitaev. Quantum computations: Algorithms and error correction. Russ. Math. Surv. , 52(6):1191–1249, 1997

    1997

  11. [19]

    M. P. da Silva et al. Demonstration of logical qubits and repeated error correction with better-than-physical error rates, 2024. arXiv: 2404.02280

    2024 arXiv

  12. [20]

    M. A. Nielsen et al. Quantum Computation and Quan- tum Information. Cambridge University Press, 2010

    2010

  13. [21]

    Paetznick et al

    A. Paetznick et al. Fault-tolerant ancilla preparation and noise threshold lower bounds for the 23-qubit Golay code, 2013. arXiv: 1106.2190

    2013 arXiv

  14. [22]

    Peham et al

    T. Peham et al. Automated Synthesis of Fault-Tolerant State Preparation Circuits for Quantum Error Correction Codes, 2024. arXiv: 2408.11894

    2024 arXiv

  15. [23]

    Peham et al

    T. Peham et al. Depth-Optimal Synthesis of Clifford Circuits with SAT Solvers. In 2023 IEEE Int. Conf. Quantum Comput. Eng. QCE , volume 01, pages 802– 813, 2023

    2023

  16. [24]

    Pogorelov et al

    I. Pogorelov et al. Experimental fault-tolerant code switching, 2024. arXiv: 2403.13732

    2024 arXiv

  17. [25]

    Postler et al

    L. Postler et al. Demonstration of fault-tolerant univer- sal quantum gate operations. Nature, 605(7911):675– 680, 2022

    2022

  18. [26]

    Preskill

    J. Preskill. Reliable quantum computers. Proc. R. Soc. Lond. A, 454(1969):385–410, 1998

    1969

  19. [27]

    https://www.markus-grassl.de/QECC/CSS/index.html

    QECC: Bounds and Circuits for wsd CSS Codes. https://www.markus-grassl.de/QECC/CSS/index.html

  20. [28]

    B. W. Reichardt et al. Demonstration of quantum com- putation and error correction with a tesseract code,

  21. [29]

    Ryan-Anderson et al

    C. Ryan-Anderson et al. Realization of real-time fault-tolerant quantum error correction. Phys. Rev. X , 11(4):041058, 2021

    2021

  22. [30]

    P. W. Shor. Fault-tolerant quantum computation. In Proc. 37th Conf. Found. Comput. Sci. Pages 56–65, Burlington, VT, USA. IEEE Comput. Soc. Press, 1996

    1996

  23. [31]

    P. W. Shor. Scheme for reducing decoherence in quan- tum computer memory. Phys. Rev. A , 52(4):R2493– R2496, 1995

    1995

  24. [32]

    Shutty et al

    N. Shutty et al. Decoding Merged Color-Surface Codes and Finding Fault-Tolerant Clifford Circuits Using Solvers for Satisfiability Modulo Theories. Phys. Rev. Applied, 18(1):014072, 2022

    2022

  25. [33]

    A. M. Steane. Error Correcting Codes in Quantum Theory. Phys. Rev. Lett., 77(5):793–797, 1996

    1996

  26. [34]

    A. M. Steane. Simple quantum error-correcting codes. Phys. Rev. A, 54(6):4741–4751, 1996

    1996

  27. [35]

    A. Steane. Quantum Reed-Muller codes. IEEE Trans. Inf. Theory, 45(5):1701–1703, 1999

    1999

  28. [36]

    Wille et al

    R. Wille et al. The MQT Handbook: A Summary of Design Automation Tools and Software for Quantum Computing, 2024. arXiv: 2405.17543

    2024 arXiv

  29. [37]

    D. Winter. Dpwinter/qsample, 2024

    2024

  30. [38]

    Zen et al

    R. Zen et al. Quantum Circuit Discovery for Fault- Tolerant Logical State Preparation with Reinforcement Learning, 2024. arXiv: 2402.17761

    2024

Pith tools

Reviewed August 10, 2026 · model on record in the stance chip above.