Pith. sign in

REVIEW 3 major objections 5 minor 53 references

One kernel captures every diagonal logical gate of a CSS code.

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

T0 review · deepseek-v4-flash

2026-08-01 14:58 UTC pith:3OMEGTS4

load-bearing objection Useful algorithmic tool: kernel of A* finds diagonal locality-preserving gates; main risk is unproven filtration subroutine, not the Eq. (10) cleaning step. the 3 major comments →

arxiv 2607.26477 v1 pith:3OMEGTS4 submitted 2026-07-29 quant-ph

Finding diagonal logical gates in CSS codes and circuits

Andreas Bauer This is my paper
classification quant-ph
keywords quantum error correctionCSS codesdiagonal logical gatestransversal gatesClifford hierarchykernel of pullbackspacetime logical gatesquantum low-density parity-check codes
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

The paper claims that the set of diagonal logical gates of a CSS code—or of a CSS syndrome-extraction circuit, interpreted in spacetime—that can be built from any chosen collection of small "ansatz" gates is exactly the kernel of a group homomorphism derived from the X-check matrix. This turns a potentially hard search over non-Clifford gates into linear algebra over finite abelian 2-groups, computable in O(n^3) time in a straightforward dense implementation. The same machinery handles higher levels of the Clifford hierarchy, arbitrary diagonal gates, qudits of prime or composite dimension, and a class of non-diagonal gates; it also subsumes the known triorthogonality condition. A reader should care because magic-state and non-Clifford protocols are often bottlenecked by finding codes or circuits with suitable transversal or locality-preserving gates, and this gives an automated way to enumerate them.

Core claim

The paper establishes that a diagonal gate V_c, written as a product of prescribed T, CS, and CCZ ansatz gates, preserves the code space of a CSS code exactly when the pullback A* of the X-check matrix annihilates the coefficient vector c, i.e. A*c = 0. Concretely, composing the phase function S_c with the boundary map A yields another third-order function on X-checks; the gate is logical if and only if that function is identically zero. The kernel of A* is a subgroup of the finite abelian 2-group of ansatz coefficients, so finding all logical gates reduces to computing that kernel. The paper develops a "filtration" method that expresses the kernel via a cascade of binary (Z2) Gaussian elimi

What carries the argument

The central object is the pullback homomorphism A* from the group of physical phase functions (built from prescribed ansatz gates) to the group of phase functions on X-checks. For third-order gates, the physical group is Z2^triples × Z4^pairs × Z8^qubits generated by CCZ, CS, and T gates, and the check group is the analogous group built from X-checks. The identity S_c ∘ A = S_{A*c} is what makes code-space preservation equivalent to A*c = 0, so the kernel of A* is exactly the set of allowed logical gates. The filtration algorithm computes this kernel by successively solving conditions modulo 2, modulo 4, and modulo 8, using only bit-packed Z2 linear algebra as its inner loop.

Load-bearing premise

The load-bearing premise is a "local cleaning" property: for every X-check, any valid configuration of the code restricted to the small patch touched by that check equals a boundary configuration of the X-checks. The paper asserts this follows from growing code distance with bounded-degree local interactions, but gives no full proof; if it fails, the algebraic shortcut A*c = 0 could misidentify or miss logical gates.

What would settle it

Construct a CSS code family with growing distance and bounded-degree Tanner graph in which some local region L_j carries logical information, e.g., a Z measurement in that region yields a nontrivial logical outcome. In such a code, the local-cleaning equation fails, and one can test whether some c with A*c = 0 nevertheless fails to preserve the code space (or vice versa). A more direct check: run the published implementation on a battery of small qLDPC codes and verify that every returned kernel element actually preserves the code space; a single counterexample would refute the completeness cl

Watch this falsifier — get emailed when new claim-graph text bears on it.

If this is right

  • If correct, finding all locality-preserving diagonal logical gates in a qLDPC code or CSS circuit is a polynomial-time problem in the number of qubits, including gates that act on overlapping regions, folding gates, and higher-order symmetries.
  • The method subsumes the triorthogonality condition and reproduces known transversal gates for toric, color, fracton, and bivariate-bicycle codes; it also finds a third-order gate in the dual 3D color code with the same logical action as the T gate.
  • The same kernel condition applies to spacetime logical gates in CSS circuits, meaning non-Clifford insertions into syndrome-extraction circuits can be enumerated automatically, including protocols of the magic-state-cultivation type.
  • Higher Clifford levels and arbitrary diagonal gates reduce to kernels of homomorphisms between finite abelian groups or Z-modules, so the approach is not limited to T, CS, and CCZ gates.
  • For composite-dimensional qudits, the search splits into independent prime blocks, so the method extends to qudit stabilizer codes and can be solved separately for each prime power factor.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • Beyond the paper: the kernel view suggests a converse use—computing that the kernel contains only trivial elements would certify that a given code family has no non-Clifford diagonal logical gate built from the ansatz, a useful no-go result for protocol design.
  • Beyond the paper: the kernel computation could be embedded in a code-search loop, testing many candidate qLDPC codes for a desired gate set; the paper lists code-gate co-optimization only as future work, but the algebraic reduction makes such a loop feasible.
  • Beyond the paper: the local-cleaning step is the likely validity boundary; running the algorithm on codes with distance growing more slowly than the check weight, and comparing against brute-force code-space preservation, would empirically mark where the shortcut A*c = 0 breaks down.
  • Beyond the paper: because the algorithm finds physical implementations as well as logical actions, the freedom to choose ansatz locations means the results could be compiled directly into circuit layouts that are convenient for a given hardware platform.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 5 minor

Summary. The paper proposes an efficient method to find all diagonal logical gates of a CSS code (and certain spacetime logical gates of CSS circuits) that can be composed from a prescribed set of ansatz gates. The main mathematical claim is that gate coefficients c preserve the code space exactly when the pullback homomorphism A* on phase functions annihilates c, i.e., A*c=0 (Eq. 15). In the fault-tolerant qLDPC setting, the exact condition (Eq. 9) is reduced to this kernel condition using a local-cleaning assertion (Eq. 10). The paper gives explicit coefficient-matrix formulas for T, CS, and CCZ ansatz gates (Eqs. 25–30), a ``filtration'' algorithm for computing kernels of homomorphisms between finite abelian 2-groups (Algorithms 1–2), and generalizations to spacetime circuits, higher Clifford levels, arbitrary diagonal gates, and qudits. A Python implementation is provided, with benchmarks on the 2D color code and a newly reported gate in the dual 3D color code.

Significance. If the main claims are correct, this is a valuable contribution: it unifies and extends the triorthogonality framework, reduces gate-finding to a tractable abelian-group kernel problem, and ships a reproducible implementation. The detailed coefficient computations in Section 2.2 are internally consistent, and the spacetime interpretation in Section 3.1 broadens the applicability. The strengths are the clean algebraic formulation, the concrete algorithmic proposal with O(n^3) dense runtime, and the inclusion of code and examples. The two main caveats are that the reduction from Eq. (9) to Eq. (11) rests on an unproved local-cleaning assertion, and the filtration algorithms are only informally justified. Both are load-bearing for the central claims and need to be addressed by proofs or explicit references.

major comments (3)
  1. [Sec. 2.1, Eq. (10)] The reduction from the exact code-space condition (9) to the kernel condition (11) relies on the assertion that for every a in ker(B), the restriction of a to the constant-size region L_j is the restriction of some boundary Aα. The paper justifies this in one sentence by saying that otherwise a Z measurement on L_j would reveal logical information. This is not a proof. Please provide a rigorous argument. One valid route is: if a|L_j is not in im(A)|L_j, choose a linear functional φ on the binary vector space over L_j that vanishes on im(A)|L_j but φ(a|L_j)=1; the corresponding Z-type Pauli P supported on L_j commutes with every X-check and has eigenvalue (-1)^{φ(a|L_j)} on the logical state |[a]>, so it is a nontrivial logical operator of weight ≤|L_j|, contradicting growing distance. Also, the logical⇒A*c=0 direction can be shown directly from (9) by induction on α without invoking (10)
  2. [Sec. 2.3, Algorithms 1 and 2] No formal correctness proof is given for the filtration kernel algorithm. The claims that the block matrix in Eq. (46) is a kernel isomorphism and that the three-step composition K=K0L1L2 in Algorithm 2 has image exactly ker(X) are nontrivial, especially the overlap-removal step in Eqs. (41)–(46) and the handling of the Z8-valued components in Eqs. (48)–(50). Please add theorem statements and proofs (or a complete reference) for both algorithms. In particular, the notation in Eqs. (48)–(49) is confusing: after applying mod4 and dividing by 2, the Z8 block should yield Z4-valued coefficients for the next stage, not simply Z2; the block structure of the maps should be spelled out.
  3. [Sec. 3.1, spacetime logical gates] The spacetime generalization applies the same reduction (Eq. (9) to the kernel condition) to the Z-decoding graph A of a CSS circuit. This requires an analogue of the local-cleaning assertion (10) for the decoding graph, e.g., local detectors and a growing decoding distance. The paper does not state this assumption or prove it. Since spacetime logical gates are a major advertised contribution, please state the precise condition and provide the corresponding proof or citation. Similarly, the asserted spacetime fault-tolerance condition (the product-state property after removing a ball) is not proven; clarify that it is a known result from Refs. [18–21] or give a proof.
minor comments (5)
  1. [Sec. 2.3, Eqs. (48)–(49)] The codomain in Eq. (48) is written as Z2^{m0} × Z4^{m1+m2}; this is not consistent with the original codomain Z2^{m0}×Z4^{m1}×Z8^{m2}. Please clarify how the mod-4 reduction and division by 2 act blockwise.
  2. [Sec. 2.2, Eq. (27)] The expansion for the CS pullback is very long and hard to verify. Consider moving the detailed algebra to an appendix, keeping only the final coefficient formulas in the main text.
  3. [Sec. 2.3, Algorithm 1] The construction of the ``Z2 staggered kernel isomorphism'' Z from the RREF is only described in words. An explicit procedure or pseudocode would make the algorithm reproducible without relying on the implementation.
  4. [Sec. 2.1, Eq. (10) and Sec. 2.4] The definition of L_j uses the phrase ``share at least one qubit with the support of Ae_j''; please define the supports (sets of qubits) explicitly. Also, the runtime analysis in Sec. 2.3 states O(n^3) but does not analyze the cost of constructing the sparse representation of A*; add a sentence justifying the O(n) support bound after restricting to the image.
  5. [References] Some references are given only as URLs (e.g., Refs. [29], [39], [40]). For a journal, please provide full bibliographic information or a note on access dates.

Circularity Check

0 steps flagged

No circularity: the kernel condition A*c=0 is derived from the code-space preservation condition rather than assumed; self-citations are contextual, not load-bearing.

full rationale

The central derivation is self-contained. Starting from the exact code-space preservation condition Eq. (9), the paper defines the pullback A* via Eq. (12) and computes its coefficient matrix directly from the X-check matrix A (Eqs. (25)-(30)). Eq. (15) is then a kernel condition, and computing that kernel is a standard finite-abelian-group linear algebra problem. The derivation does not fit parameters to the target gates, does not rename a known result, and does not invoke a uniqueness theorem from the authors' prior work. The self-citations (e.g., Refs. [45,47,51]) are contextual: they supply tensor-network/path-integral language and the qudit generalization of higher-order functions, but the load-bearing equivalence A*c=0 is derived in the text, and the implementation is benchmarked against independent known gates (toric and color codes, fracton codes, bivariate bicycle codes), with the dual-3D-color-code gate reported as an application rather than as a fitted prediction. Two gaps are real but non-circular: the local-cleaning assertion used in Eq. (10) is justified only by a short growing-distance argument rather than a full proof, and Algorithms 1-2 for the filtration kernel computation are described informally with the paper itself noting uncertainty about the method's provenance. Neither gap assumes the conclusion. The footnote giving the exact condition ((id|A)* - id)c = 0 explicitly separates the full Eq. (9) condition from the simplified kernel, confirming that the simplification is not definitional. No circular step is present.

Axiom & Free-Parameter Ledger

0 free parameters · 5 axioms · 0 invented entities

No fitted numbers; the ansatz radius r is a user input, not a fit. The main load-bearing assumptions are the CSS/qLDPC locality-cleaning lemma (Eq. 10) and the Clifford-hierarchy phase-function form. No new physical entities are postulated.

axioms (5)
  • domain assumption For a qLDPC family with growing distance and degree-bounded Tanner graph, every a in ker(B) restricted to a constant-size region L_j equals the restriction of some X-boundary Aα, so no local Z information is encoded.
    Introduced in Section 2.1 around Eq. (10) without proof; this is what reduces the exact code-space condition to A*c=0 and is essential to the claim that all locality-preserving gates are found.
  • domain assumption Every qubit diagonal gate in the third Clifford hierarchy can be written as a product of CCZ, CS, and T gates with the phase function form Eq. (6), with coefficients in Z2 x Z4 x Z8.
    Rests on Refs. [29,36]; stated in Section 2.1. If false, the ansatz set would not exhaust locality-preserving diagonal gates.
  • standard math The 'filtration' kernel computation correctly computes kernels of homomorphisms of finite abelian 2-groups using only Z2 RREF subroutines.
    Described in Section 2.3 and Appendix A; correctness is argued informally, not as a formal theorem.
  • domain assumption A CSS circuit can be represented by a GHZ/sum tensor network with +1 postselected measurements, and spacetime logical gates satisfy the same A*c=0 condition.
    Used in Section 3.1; relies on ZX-calculus equivalences [42-44] and prior spacetime formalism [45-47].
  • standard math Standard finite-field linear algebra (Z2 Gaussian elimination, image completion) works in polynomial time.
    Used by Algorithms 1-4 for the O(n^3) runtime claim.

pith-pipeline@v1.3.0-daily-deepseek · 25255 in / 17891 out tokens · 207981 ms · 2026-08-01T14:58:07.113992+00:00 · methodology

0 comments
read the original abstract

Finding efficient schemes for non-Clifford logic or magic state preparation is one of the central challenges on the way to fault-tolerant quantum computation. Many of the proposed schemes rely on diagonal non-Clifford logical gates acting on CSS codes in space or decorating CSS-type syndrome-extraction circuits in spacetime. Here we propose and implement efficient algorithms to find all (spacetime) logical gates of a given CSS code (circuit) composed from a prescribed set of ansatz gates. Depending on the choice of ansatz gates, this means finding transversal gates, more general locality-preserving logical circuits, folding gates, or similar. While we focus on qubit diagonal gates in the Clifford hierarchy, we also discuss the generalization to arbitrary diagonal non-hierarchy gates, certain non-diagonal gates, as well as prime and composite-dimensional qudits. Our method works by rephrasing code-space preserving gates as the kernel of the ``pullback'' of the $X$ check matrix onto phase functions, which maps between finite abelian 2-groups. We implement a fast ``filtration'' method to find this kernel. The runtime for finding fault-tolerant logical gates in a qLDPC code with $O(n)$ qubits or a circuit with $O(n)$ gates in a naive dense implementation is $O(n^3)$, with potential for improvement making use of sparsity.

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

53 extracted references · 39 linked inside Pith

  1. [1]

    Universal quan- tum computation with ideal clifford gates and noisy ancillas

    Sergei Bravyi and Alexei Kitaev. “Universal quan- tum computation with ideal clifford gates and noisy ancillas”. Phys. Rev. A71, 022316 (2005). arXiv:quant-ph/0403025

    Pith/arXiv arXiv 2005

  2. [2]

    Magic state distillation with low overhead

    Sergey Bravyi and Jeongwan Haah. “Magic state distillation with low overhead”. Phys. Rev. A86, 052329 (2012). arXiv:1209.2426

    Pith/arXiv arXiv 2012

  3. [3]

    Magic state distillation: Not as costly as you think

    Daniel Litinski. “Magic state distillation: Not as costly as you think”. Quantum3, 205 (2019). arXiv:1905.06903

    Pith/arXiv arXiv 2019

  4. [4]

    Constant-overhead magic state distilla- tion

    Adam Wills, Min-Hsiu Hsieh, and Hayata Ya- masaki. “Constant-overhead magic state distilla- tion” (2024). arXiv:2408.07764

    Pith/arXiv arXiv 2024

  5. [5]

    Restrictions on transversal encoded quantum gate sets

    Bryan Eastin and Emanuel Knill. “Restrictions on transversal encoded quantum gate sets”. Phys. Rev. Lett.102, 110502 (2009). arXiv:0811.4262

    Pith/arXiv arXiv 2009

  6. [6]

    Dimensional jump in quantum er- ror correction

    H. Bombin. “Dimensional jump in quantum er- ror correction”. New Journal of Physics18, 043038 (2016). arXiv:1412.5079

    Pith/arXiv arXiv 2016

  7. [7]

    Univer- sal fault-tolerant quantum computation with only transversal gates and error correction

    Adam Paetznick and Ben W. Reichardt. “Univer- sal fault-tolerant quantum computation with only transversal gates and error correction”. Phys. Rev. Lett.111, 090505 (2013). arXiv:1304.3709. 17

    Pith/arXiv arXiv 2013

  8. [8]

    Universal transversal gates with color codes - a simplified approach

    Aleksander Kubica and Michael E. Beverland. “Universal transversal gates with color codes - a simplified approach”. Phys. Rev. A91, 032330 (2015). arXiv:1410.0069

    Pith/arXiv arXiv 2015

  9. [9]

    The cost of universality: A com- parative study of the overhead of state distillation and code switching with color codes

    Michael E. Beverland, Aleksander Kubica, and Krysta M. Svore. “The cost of universality: A com- parative study of the overhead of state distillation and code switching with color codes”. PRX Quan- tum2, 020341 (2021). arXiv:2101.02211

    Pith/arXiv arXiv 2021

  10. [10]

    Non- clifford and parallelizable fault-tolerant logical gates on constant and almost-constant rate ho- mological quantum ldpc codes via higher sym- metries

    Guanyu Zhu, Shehryar Sikander, Elia Portnoy, An- drew W. Cross, and Benjamin J. Brown. “Non- clifford and parallelizable fault-tolerant logical gates on constant and almost-constant rate ho- mological quantum ldpc codes via higher sym- metries”. PRX Quantum6, 040361 (2025). arXiv:2310.16982

    arXiv 2025

  11. [11]

    Transversal dimension jump for product qldpc codes

    Christine Li, John Preskill, and Qian Xu. “Transversal dimension jump for product qldpc codes” (2025). arXiv:2510.07269

    arXiv 2025

  12. [12]

    Very low overhead fault-tolerant magic state preparation using redundant ancilla encoding and flag qubits

    Christopher Chamberland and Kyungjoo Noh. “Very low overhead fault-tolerant magic state preparation using redundant ancilla encoding and flag qubits”. npj Quantum Information6, 91 (2020). arXiv:2003.03049

    Pith/arXiv arXiv 2020

  13. [13]

    Fault-tolerant post- selection for low overhead magic state prepa- ration

    H´ ector Bomb ´ ın, Mihir Pant, Sam Roberts, and Karthik I. Seetharam. “Fault-tolerant post- selection for low overhead magic state prepa- ration”. PRX Quantum5, 010302 (2024). arXiv:2212.00813

    Pith/arXiv arXiv 2024

  14. [14]

    Magic state cultivation: growing t states as cheap as cnot gates

    Craig Gidney, Noah Shutty, and Cody Jones. “Magic state cultivation: growing t states as cheap as cnot gates” (2024). arXiv:2409.17595

    Pith/arXiv arXiv 2024

  15. [15]

    Magic state cultivation on a superconducting quantum processor

    Google Quantum AI. “Magic state cultivation on a superconducting quantum processor” (2025). arXiv:2512.13908

    arXiv 2025

  16. [16]

    2d quantum computation with 3d topological codes

    Hector Bombin. “2d quantum computation with 3d topological codes” (2018). arXiv:1810.09571

    Pith/arXiv arXiv 2018

  17. [17]

    A fault-tolerant non-clifford gate for the surface code in two dimensions

    Benjamin J. Brown. “A fault-tolerant non-clifford gate for the surface code in two dimensions”. Sci. Adv.6, eaay4929 (2020). arXiv:1903.11634

    Pith/arXiv arXiv 2020

  18. [18]

    Universal fault tolerant quantum computing in 2d without getting tied in knots

    Margarita Davydova, Andreas Bauer, Julio C. Magdalena de la Fuente, Mark Webster, Dominic J. Williamson, and Benjamin J. Brown. “Universal fault tolerant quantum computing in 2d without getting tied in knots” (2025). arXiv:2503.15751

    Pith/arXiv arXiv 2025

  19. [19]

    Low-overhead non-clifford topo- logical fault-tolerant circuits for all non-chiral abelian topological phases

    Andreas Bauer. “Low-overhead non-clifford topo- logical fault-tolerant circuits for all non-chiral abelian topological phases”. Quantum 9Page 1673 (2025). arXiv:2403.12119

    Pith/arXiv arXiv 2025

  20. [20]

    Planar fault-tolerant circuits for non- clifford gates on the 2d color code

    Andreas Bauer and Julio C. Magdalena de la Fuente. “Planar fault-tolerant circuits for non- clifford gates on the 2d color code” (2025). arXiv:2505.05175

    Pith/arXiv arXiv 2025

  21. [21]

    High-threshold decoding of non-pauli codes for 2d universal- ity

    Julio C. Magdalena de la Fuente, Noa Feldman, Jens Eisert, and Andreas Bauer. “High-threshold decoding of non-pauli codes for 2d universal- ity” (2026). arXiv:2604.02033

    arXiv 2026

  22. [22]

    Non-abelian qldpc: Tqft formalism, ad- dressable gauging measurement and application to magic state fountain on 2d product codes

    Guanyu Zhu, Ryohei Kobayashi, and Po-Shen Hsin. “Non-abelian qldpc: Tqft formalism, ad- dressable gauging measurement and application to magic state fountain on 2d product codes” (2026). arXiv:2601.06736

    arXiv 2026

  23. [23]

    Fast magic state prepa- ration by gauging higher-form transversal gates in parallel

    Dominic J. Williamson. “Fast magic state prepa- ration by gauging higher-form transversal gates in parallel” (2026). arXiv:2601.22939

    arXiv 2026

  24. [24]

    Non-abelian quantum low-density parity check codes and non-clifford op- erations from gauging logical gates via measure- ments

    Maine Christos, Chiu Fan Bowen Lo, Vedika Khe- mani, and Rahul Sahay. “Non-abelian quantum low-density parity check codes and non-clifford op- erations from gauging logical gates via measure- ments” (2026). arXiv:2602.12228

    arXiv 2026

  25. [25]

    Cups and gates i: Cohomol- ogy invariants and logical quantum opera- tions

    Nikolas P. Breuckmann, Margarita Davydova, Jens N. Eberhardt, and Nathanan Tanti- vasadakarn. “Cups and gates i: Cohomol- ogy invariants and logical quantum opera- tions”. Commun. Math. Phys.407, 86 (2026). arXiv:2410.16250

    Pith/arXiv arXiv 2026

  26. [26]

    Transversal non-clifford gates for quantum ldpc codes on sheaves

    Ting-Chun Lin. “Transversal non-clifford gates for quantum ldpc codes on sheaves” (2024). arXiv:2410.14631

    Pith/arXiv arXiv 2024

  27. [27]

    Transver- sal non-clifford gates on almost-good quantum ldpc and quantum locally testable codes

    Yiming Li, Zimu Li, and Zi-Wen Liu. “Transver- sal non-clifford gates on almost-good quantum ldpc and quantum locally testable codes” (2026). arXiv:2604.01874

    Pith/arXiv arXiv 2026

  28. [28]

    Unfolding the color code

    Beni Yoshida Aleksander Kubica and Fernando Pastawski. “Unfolding the color code”. New J. Phys.17, 083026 (2015). arXiv:1503.02065

    Pith/arXiv arXiv 2015

  29. [29]

    url:https://github.com/ andibau13/diagonal-gate-finder

    Andreas Bauer (2026). url:https://github.com/ andibau13/diagonal-gate-finder

    2026

  30. [30]

    Codes and protocols for distillingt, controlled- s, and toffoli gates

    Jeongwan Haah and Matthew B. Hastings. “Codes and protocols for distillingt, controlled- s, and toffoli gates”. Quantum2, 71 (2018). arXiv:1709.02832

    Pith/arXiv arXiv 2018

  31. [31]

    Transversal diagonal logical operators for stabiliser codes

    Mark A. Webster, Armanda O. Quintavalle, and Stephen D. Bartlett. “Transversal diagonal logical operators for stabiliser codes”. New J. Phys.25, 103018 (2023). arXiv:2303.15615

    Pith/arXiv arXiv 2023

  32. [32]

    Logical clifford synthesis for stabilizer codes

    Narayanan Rengaswamy, Robert Calderbank, Swanand Kadhe, and Henry D. Pfister. “Logical clifford synthesis for stabilizer codes”. IEEE Trans. Quantum Engg.1, 1–17 (2019). arXiv:1907.00310. 18

    Pith/arXiv arXiv 2019

  33. [33]

    Fault-tolerant logical clifford gates from code au- tomorphisms

    Hasan Sayginel, Stergios Koutsioumpas, Mark Webster, Abhishek Rajput, and Dan E Browne. “Fault-tolerant logical clifford gates from code au- tomorphisms” (2024). arXiv:2409.18175

    Pith/arXiv arXiv 2024

  34. [34]

    Au- tomated logical clifford gadgets for heteroge- neous architectures via chain maps

    Asmae Benhemou and Noah Berthusen. “Au- tomated logical clifford gadgets for heteroge- neous architectures via chain maps” (2026). arXiv:2607.02482

    Pith/arXiv arXiv 2026

  35. [35]

    Quan- tum teleportation is a universal computational primitive

    Daniel Gottesman and Isaac L. Chuang. “Quan- tum teleportation is a universal computational primitive”. Nature402, 390–393 (1999). arXiv:quant-ph/9908010

    Pith/arXiv arXiv 1999

  36. [36]

    Diagonal gates in the clifford hierarchy

    Shawn X. Cui, Daniel Gottesman, and Anirudh Kr- ishna. “Diagonal gates in the clifford hierarchy”. Phys. Rev. A95, 012329 (2017). arXiv:1608.06596

    Pith/arXiv arXiv 2017

  37. [37]

    Solving linear equations over finitely generated abelian groups

    Ren´ e Hartung. “Solving linear equations over finitely generated abelian groups” (2010). arXiv:1007.2477

    Pith/arXiv arXiv 2010

  38. [38]

    Exact solution of linear equations using p-adic expansions

    J.D. Dixon. “Exact solution of linear equations using p-adic expansions”. Numerische Mathematik 40, 137–142 (1982). url:http://eudml.org/doc/ 132821

    1982

  39. [39]

    url:https://github.com/ andibau13/twogroup-linalg

    Andreas Bauer (2026). url:https://github.com/ andibau13/twogroup-linalg

    2026

  40. [40]

    url:https://github.com/ akissinger/bitgauss

    Aleks Kissinger (2025). url:https://github.com/ akissinger/bitgauss

    2025

  41. [41]

    High-threshold and low- overhead fault-tolerant quantum memory

    Sergey Bravyi, Andrew W. Cross, Jay M. Gambetta, Dmitri Maslov, Patrick Rall, and Theodore J. Yoder. “High-threshold and low- overhead fault-tolerant quantum memory”. Nature 627, 778–782 (2024). arXiv:2308.07915

    Pith/arXiv arXiv 2024

  42. [42]

    Picturing quan- tum processes: A first course in quantum theory and diagrammatic reasoning

    Bob Coecke and Aleks Kissinger. “Picturing quan- tum processes: A first course in quantum theory and diagrammatic reasoning”. Cambridge Univer- sity Press. (2017)

    2017

  43. [43]

    Zx-calculus for the working quantum computer scientist

    John van de Wetering. “Zx-calculus for the working quantum computer scientist” (2020). arXiv:2012.13966

    Pith/arXiv arXiv 2020

  44. [44]

    Phase-free zx diagrams are css codes (...or how to graphically grok the surface code)

    Aleks Kissinger. “Phase-free zx diagrams are css codes (...or how to graphically grok the surface code)” (2022). arXiv:2204.14038

    Pith/arXiv arXiv 2022

  45. [45]

    Topological error correcting pro- cesses from fixed-point path integrals

    Andreas Bauer. “Topological error correcting pro- cesses from fixed-point path integrals”. Quantum 8Page 1288 (2024). arXiv:2303.16405

    Pith/arXiv arXiv 2024

  46. [46]

    Unify- ing flavors of fault tolerance with the zx calcu- lus

    Hector Bombin, Daniel Litinski, Naomi Nickerson, Fernando Pastawski, and Sam Roberts. “Unify- ing flavors of fault tolerance with the zx calcu- lus” (2024) arXiv:2303.08829

    Pith/arXiv arXiv 2024

  47. [47]

    The x+y floquet code: A simple example for topological quantum computation in the path integral approach

    Andreas Bauer. “The x+y floquet code: A simple example for topological quantum computation in the path integral approach”. Phys. Rev. A111, 032413 (2025). arXiv:2408.07265

    Pith/arXiv arXiv 2025

  48. [48]

    Classification of topologically protected gates for local stabilizer codes

    Sergey Bravyi and Robert K¨ onig. “Classification of topologically protected gates for local stabilizer codes”. Phys. Rev. Lett.110, 170503 (2013). arXiv:1206.1609

    Pith/arXiv arXiv 2013

  49. [49]

    Classification of transversal gates in qubit stabi- lizer codes

    Jonas T. Anderson and Tomas Jochym-O’Connor. “Classification of transversal gates in qubit stabi- lizer codes”. Quantum Inf. Comput.16, 0771– 0802 (2016). arXiv:1409.8320

    Pith/arXiv arXiv 2016

  50. [50]

    The disjointness of stabi- lizer codes and limitations on fault-tolerant log- ical gates

    Theodore J. Yoder Tomas Jochym-O’Connor, Aleksander Kubica. “The disjointness of stabi- lizer codes and limitations on fault-tolerant log- ical gates”. Phys. Rev. X8, 021047 (2018). arXiv:1710.07256

    Pith/arXiv arXiv 2018

  51. [51]

    Quadratic ten- sors as a unification of clifford, gaussian, and free- fermion physics

    Andreas Bauer and Seth Lloyd. “Quadratic ten- sors as a unification of clifford, gaussian, and free- fermion physics” (2026). arXiv:2601.15396

    arXiv 2026

  52. [52]

    Solving sparse linear equations over finite fields

    D. Wiedemann. “Solving sparse linear equations over finite fields”. IEEE Transactions on Informa- tion Theory32, 54–62 (1986)

    1986

  53. [53]

    Commuting pauli hamiltonians as maps between free modules

    Jeongwan Haah. “Commuting pauli hamiltonians as maps between free modules”. Comm. Math. Phys.324, 351–399 (2013). arXiv:1204.1063. A Solving 2-group linear equations In this appendix, we show how to solve the linear equa- tionXk=bfor a homomorphismXas in Eq.(31), using the filtration method. This is important for ex- ample for finding physical realization...

    Pith/arXiv arXiv 2013