Pith. sign in

REVIEW 2 major objections 6 minor 71 references

Targeted Clifford logical gates for hypergraph product codes

T0 review · 2 major / 6 minor · reviewed 2026-08-12 · deepseek-v4-flash

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

Pith's one-line read For hypergraph product codes, this paper constructs ancilla-free Clifford circuits that implement targeted logical Phase, Hadamard, CNOT, and CZ gates on every logical qubit, with support and depth Θ(√n).

desk verdict Explicit ancilla-free targeted Clifford circuits for any HGP code, with a solid framework and a manageable dependency on an imported basis theorem. read the letter →

arxiv 2411.17050 v3 pith:66HBBVPT submitted 2024-11-26 quant-ph cs.ITmath.IT

Adway Patra , Alexander Barg This is my paper · ORCID
classification quant-phcs.ITmath.IT MSC 81P6894B05 PACS 03.67.Pp
keywords hypergraphproductcodeslogicalCliffordgatesquantumLDPCsymplecticmatricesCSScircuitsynthesistoriccodefault-tolerantcomputing
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 aims to show that every hypergraph product (HGP) code can support a full set of targeted logical Clifford gates without any ancilla qubits. The strategy is to represent a desired logical operation—Phase, Hadamard, CNOT, or CZ—as a symplectic matrix acting on the code's logical Pauli basis, and then to translate that matrix into a physical Clifford circuit. For HGP codes whose constituent classical codes admit strongly lower triangular kernel bases, the paper proves that each logical qubit has such a circuit with support and depth Θ(√n). This matters because targeted gates act on a chosen subset of logical qubits, giving algorithmic flexibility, whereas earlier constructions either applied only global gates or required a large number of ancillas for teleportation. The method is demonstrated by explicit 18-qubit toric code circuits.

What carries the argument

The load-bearing object is the symplectic transvection T_x(y)=y+(y,x)_s x, a one-line matrix that Theorem 3.5 uses to build arbitrary logical Clifford operations. Corollary 3.6 expresses the logical Phase, Hadamard, CNOT, and CZ gates as products of transvections labeled by logical Pauli supports, and Table 1 converts each transvection into physical Clifford gates. The HGP specialization rests on strongly lower triangular (SLT) bases: bases of ker(H_a), ker(H_a^T), ker(H_b), and ker(H_b^T) in which each vector has its own pivot position and in which paired logical X and Z operators intersect in exactly one physical qubit. These bases, imported as Theorem 4.2, make the support of each logical Pauli a single row or column of the two-sector grid, so the transvection circuits collapse to CNOT and CZ layers along that line. A final Pauli correction layer restores the phases of any stabilizers that the circuit would otherwise negate.

What would settle it

A decisive falsifier is a single hypergraph product code whose constituent parity-check matrices do not admit strongly lower triangular kernel bases with the single-overlap property; exhibiting such a code would collapse the claim that the construction covers all HGP codes. A smaller check is to simulate Algorithm 3 on the [[18,2,3]] toric code and verify that the compiled circuit's action on every logical Pauli matches the target CNOT symplectic matrix.

Watch

Extended reading notes

Core claim

The central claim is that the logical Clifford group of an HGP code can be generated by circuits whose physical action is confined to the support of a single logical Pauli operator. The paper proves this by writing each logical gate as a product of symplectic transvections built from the logical X and Z supports, then showing that with strongly lower triangular bases these supports become single lines in the code's two-sector layout. Theorems 4.4, 4.6, 4.8, and 4.10 state that ancilla-free circuits exist for targeted logical Phase, Hadamard, CNOT, and CZ gates on every logical qubit, with support χ(C)=Θ(√n) and depth δ(C)=Θ(√n). The circuits are built purely from physical Clifford gates plus one Pauli correction, and they preserve the stabilizer group with phases. The authors also give a general symplectic-matrix framework (Theorems 3.5 and 3.12) that applies to any CSS code once a logical Pauli basis is fixed.

Load-bearing premise

The construction assumes that the kernels of the two constituent parity-check matrices and their transposes admit strongly lower triangular bases in which each logical X operator meets its matching logical Z operator on exactly one physical qubit; if that basis structure is absent for some hypergraph product code, the claimed circuits and their Θ(√n) resource bounds do not follow.

Editorial extensions

If this is right

  • Any Clifford logical operation that touches a constant number of logical qubits of an HGP code can be implemented with support and depth Θ(√n), by composing the single- and two-qubit circuits with the decomposition of Theorem 3.7.
  • The logical Phase, Hadamard, CNOT, and CZ circuits use no ancilla qubits and no state injection, so the space overhead of targeted logic is limited to the Θ(√n)-qubit footprint of the gate itself.
  • The constructions preserve the stabilizer group with phases, so each circuit indeed maps codewords to codewords and enacts the intended logical operator.
  • The same symplectic-matrix framework applies to any CSS code once a logical Pauli basis is known, so other product-based code families can be handled by supplying the analogous basis.
  • The explicit [[18,2,3]] toric code circuits provide a concrete template for testing these gates in small fault-tolerant demonstrations.

Reading between the lines

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

  • A testable extension is to relax the pointwise-stabilizer assumption in Section 4 and use Theorem 3.12 to search for lower-depth or lower-support circuits on the same HGP codes; the 18-qubit toric code is small enough to benchmark both versions.
  • The circuit's support being a single row or column in the two-grid layout suggests the construction may map directly to planar hardware architectures for HGP codes; a concrete check would be to estimate routing overhead when the CNOT layers are constrained to nearest-neighbor connectivity.
  • Because the symplectic framework is not tied to the HGP tensor structure, one can carry the same construction to other CSS or product code families once an explicit logical Pauli basis is supplied, with the natural next cases being homological product codes and related qLDPC families.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

2 major / 6 minor

Summary. The paper develops a symplectic-matrix framework for designing logical Clifford circuits for CSS codes, then applies it to hypergraph product (HGP) codes. The main results (Theorems 4.4, 4.6, 4.8, 4.10) construct ancilla-free physical Clifford circuits realizing targeted logical Phase, Hadamard, CNOT, and CZ gates on logical qubits of an HGP code, with support and depth Θ(√n) under the assumption that the constituent classical codes have linear dimension and distance and block lengths Θ(√n). The construction relies on strongly lower triangular (SLT) bases of the relevant kernel and quotient spaces, imported from [37]. The paper includes a detailed worked example for the [[18,2,3]] toric code and extensive appendices verifying the row-operation sequences and Pauli corrections.

Significance. If the SLT-basis foundation is made precise, the paper would provide the first explicit ancilla-free, targeted Clifford logical circuits for general HGP codes with Θ(√n) support and depth, improving on prior work that uses state injection or large ancilla overhead. The general framework of Section 3 is elegant and potentially of independent interest, and the appendices give detailed, checkable algebraic verifications. The toric-code circuits are a useful concrete demonstration. The main weakness is not the circuit constructions themselves but the unverified imported basis theorem on which all the resource claims rest.

major comments (2)
  1. [Definition 4.3 (Section 4.1)] Definition 4.3 as stated is a column-based notion: it requires every column of the matrix to have a pivot and the pivots to be distinct, which forces the number of rows to be at least the number of columns. For a k_a×n_a basis matrix of ker(H_a) with k_a=Θ(n_a) but k_a<n_a, this is impossible, and the paper's own toric-code example (basis vector (1,1,1), pivot set {3}) violates condition 2 because columns 1 and 2 would share pivot row 1. Since Theorem 4.2 and all of Section 4 rest on this definition, the paper needs to state the correct (presumably row-based) SLT notion, or quote the definition from [37] verbatim, and verify that it applies to the bases used.
  2. [Theorem 4.2 (Section 4.1)] Theorem 4.2 is imported from [37] without proof and without a precise statement of the existence hypotheses. The main theorems (4.4, 4.6, 4.8, 4.10) assert circuits for 'any HGP code,' but their proofs rely on characteristics of the SLT bases that are not guaranteed by the stated definition: e.g., in Theorem 4.8(a) the proof uses supp(u)∩supp(v)=∅ for distinct left-sector logical qubits, and in Theorem 4.10(b) it selects x∈I1\I2 and x̄∈I2\I1. These require that each basis vector a_i (or β_l) vanish at the pivot coordinates of the other basis vectors, a property that neither Definition 4.3 nor the cited theorem as stated establishes. The authors should either prove the basis construction, or state the exact theorem from [37] with all hypotheses, and should qualify Theorems 4.4–4.10 to the codes for which such bases are known to exist.
minor comments (6)
  1. [Theorem 4.4 proof] The formula δ=2|a_i| is inconsistent with Definition 4.2, since the |a_i|-1 CNOTs in each of the two layers of Algorithm 1 all share the same target qubit x and therefore require |a_i|-1 sequential layers each; the stated exact value is off by a constant, although the Θ(|a_i|) scaling remains correct.
  2. [Theorem 4.8 proof] The cases in the proof are mislabeled: the paragraph labeled (a) treats logical qubits in different sectors, while the paragraph labeled (b) treats the same sector, contrary to the statement of the theorem. The same swap occurs in the proof of Theorem 4.10.
  3. [Theorem 4.6 proof] The depth count 2(|I|+|J|)+2 appears to overcount by 2; direct counting of gates acting on qubit ρ in Algorithm 2 gives 2(|I|+|J|).
  4. [Abstract and Section 4.2] The abstract and introduction state the result for 'arbitrary codes in this family,' but Section 4.2 restricts to sequences with k_a=Θ(n_a), d_a=Θ(n_a), and n_a,n_b=Θ(√n); the main theorems should state these assumptions explicitly or the abstract should be qualified.
  5. [Section 4.2.5 and Figure 2] Figure 2 is referenced in the discussion of the Hadamard circuit, but its caption uses symbols J^* and I^* that are not otherwise defined in the surrounding text; this may confuse the reader.
  6. [Throughout] There are several typographical errors, e.g., 'rwoy' in Appendix A.4.1 and 'n =nann +mamb' in the notational conventions of Section 4.2; these should be corrected in a revision.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the targeted-Clifford construction is a parameter-free derivation that imports the SLT-basis theorem from independent prior work, and no claim reduces to its own inputs.

full rationale

The paper's core derivation (Secs. 3-4) builds symplectic matrices for logical Phase, Hadamard, CNOT, and CZ from fixed logical Pauli bases via Theorem 3.5 and Corollary 3.6, then converts row operations into physical Clifford circuits. The only load-bearing external input is Theorem 4.2, imported from Quintavalle-Webster-Vasmer [37], which supplies SLT bases of the four kernels with |X_i ∩ Z_j| = δ_ij. This is not a self-citation: [37] has no author overlap with Patra/Barg. The Θ(√n) support and depth bounds follow from the stated assumptions k_a, d_a = Θ(n_a) and n_a, n_b = Θ(√n) applied to the SLT basis weights, not from fitting or from the target result. The phase-correction arguments (Prop. 3.13, Appendices A.2.2 and A.4.2) are independent stabilizer checks. No step in the manuscript equates an input with the conclusion by construction; any concern about the scope or conditions under which [37]'s SLT bases exist is a correctness or verification risk, not circularity. Score 0.

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

No free parameters or invented entities. The construction rests on standard symplectic formalism, the SLT-basis theorem from prior work, the Θ(√n) constituent-code scaling assumption, and the pointwise-stabilizer simplifying assumption.

assumptions (4)
  • standard math Any CSS code admits a symplectic basis composed of stabilizer, logical Pauli, and destabilizer vectors, and logical Clifford automorphisms correspond to symplectic matrices (Theorem 3.1 from [39]).
    Used in Section 3.1 to convert logical Clifford operators into binary symplectic matrices.
  • domain assumption The constituent classical codes admit strongly lower triangular (SLT) bases for ker(H_a), ker(H_a^T), ker(H_b), ker(H_b^T) with the support intersection property |X_i ∩ Z_j| = δ_ij (Theorem 4.2 from [37]).
    All circuit algorithms in Section 4 depend on this basis structure to know logical Pauli supports and their disjointness.
  • domain assumption Constituent codes have k_a=Θ(n_a), d_a=Θ(n_a), and n_a,n_b scale as Θ(√n), so the SLT basis vectors have weight Θ(√n).
    Stated in the notational conventions of Section 4.2; without it the Θ(√n) support and depth bounds do not follow.
  • ad hoc to paper The constructed logical Clifford operators fix all stabilizers pointwise (Υ_g = I).
    Assumed in Section 4.2 for the explicit circuit construction; the paper notes Theorem 3.12 could relax this, but those circuits are not worked out.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Targeted Clifford logical gates for hypergraph product codes." pith.science (2026). https://pith.science/paper/66HBBVPT

@misc{pith2026241117050,
  author       = {Pith},
  title        = {Pith review of: Targeted Clifford logical gates for hypergraph product codes},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/66HBBVPT}},
  note         = {Machine review of arXiv:2411.17050}
}
abstract

Starting with an explicit framework for designing logical Clifford circuits for CSS codes, we construct logical gates for Hypergraph Product Codes. We first derive symplectic matrices for CNOT, CZ, Phase, and Hadamard operators, which together generate the Clifford group. This enables us to design explicit transformations that result in targeted logical gates for arbitrary codes in this family. As a concrete example, we give logical circuits for the $[[18,2,3]]$ toric code.

Figures

Figures reproduced from arXiv: 2411.17050 by the authors.

Figure 1
Figure 1. Two-grid view of physical qubits in HGP codes [PITH_FULL_IMAGE:figures/full_fig_p006_1.png] view at source ↗
Figure 2
Figure 2. A conceptual visualization of the logical Hadamard circuit. Here [PITH_FULL_IMAGE:figures/full_fig_p023_2.png] view at source ↗
Figure 3
Figure 3. Logical Phase gate SL for the code T3 Logical Hadamard gate on left logical qubit: By Proposition 4.5, the symplectic matrix that per￾forms the logical Hadamard operation on the left logical qubit is given by: FHL =      I9 + v ⊺u 0 v ⊺v 0 0 I9 0 0 u ⊺u 0 I9 + u ⊺v 0 0 0 0 I9      with u = (000000111) and v = (001001001). Using Algorithm 2, we obtain the circuit in [PITH_FULL_IMAGE:figures/full_fig_p029_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Logical Hadamard gate HL for the code T3 Logical left-to-right qubit CNOT gate: By Proposition 4.7, the symplectic matrix that performs logical CNOT with left and right logical qubits as control and target, respectively, has the form FHL =      I9 v ⊺v 0 0 0 I9 0 …
Figure 5
Figure 5. Figure 5: Logical CNOT gate CNOT L→R for the code T3 Logical CZ gate between the left and right logical qubit: By Proposition 4.9, the symplectic matrix that performs logical CZ between the left and right logical qubits has the form Using Proposition 4.9, we have the symplectic …
Figure 6
Figure 6. Figure 6: Logical CZ gate CZL,R for the code T3 Concluding this section, we also mention surface codes [18], which are obtained from toric codes by simply discarding the periodicity of the lattice, and represent a practically popular variant of toric codes. By construction, surf…
Figure 7
Figure 7. Figure 7: Circuit for Example A.1 Accepted in Quantum 2025-08-22, click title to verify. Published under CC-BY 4.0. 36 [PITH_FULL_IMAGE:figures/full_fig_p036_7.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

71 extracted references · 34 canonical work pages

  1. [37]

    A. O. Quintavalle, P. Webster, and M. Vasmer. Partitioning qubits in hypergraph product codes to implement logical gates. Quantum, 7:1153, Oct. 2023. doi:10.22331/q-2023-10-24-1153

    doi:10.22331/q-2023-10-24-1153 2023

  2. [1]

    Aaronson and D

    S. Aaronson and D. Gottesman. Improved simulation of stabilizer circuits. Phys. Rev. A , 70:052328, Nov 2004. doi:10.1103/PhysRevA.70.052328

    doi:10.1103/physreva.70.052328 2004

  3. [2]

    Bombin and M

    H. Bombin and M. A. Martin-Delgado. Homological error correction: classical and quantum codes. J. Math. Phys., 48(5):052105, 35, 2007. doi:10.1063/1.2731356

    doi:10.1063/1.2731356 2007

  4. [3]

    Bravyi and M

    S. Bravyi and M. B. Hastings. Homological product codes. In Proceedings of the F orty-Sixth Annual ACM Symposium on Theory of Computing , STOC ’14, page 273–282, New York, NY , USA, 2014. Association for Computing Machinery. doi:10.1145/2591796.2591870

    arXiv 2014

  5. [4]

    Bravyi and A

    S. Bravyi and A. Kitaev. Universal quantum computation with ideal Clifford gates and noisy ancillas. Physical Review A, 71(2):022316, 2005. doi:10.1103/PhysRevA.71.022316

    doi:10.1103/physreva.71.022316 2005

  6. [5]

    S. B. Bravyi and A. Y . Kitaev. Quantum codes on a lattice with boundary. arXiv preprint quant-ph/9811052, 1998. arXiv:quant-ph/9811052, doi:10.48550/arXiv.quant-ph/ 9811052

    arXiv doi:10.48550/arxiv.quant-ph/9811052 1998

  7. [6]

    N. P. Breuckmann and S. Burton. Fold-transversal Clifford gates for quantum codes. Quantum, 8:1372, 2024. arXiv:2202.06647, doi:10.22331/q-2024-06-13-1372

    arXiv 2024

  8. [7]

    N. P. Breuckmann, M. Davydova, J. N. Eberhardt, and N. Tantivasadakarn. Cups and gates I: Cohomology invariants and logical quantum operations, 2024. arXiv:2410.16250, doi: 10.48550/arXiv.2410.16250

    arXiv doi:10.48550/arxiv.2410.16250 2024

Show all 71 references
  1. [8]

    N. P. Breuckmann and J. N. Eberhardt. Quantum low-density parity-check codes.PRX Quantum, 2(4):040101, 2021. doi:10.1103/PRXQuantum.2.040101

    2021 doi

  2. [9]

    A. R. Calderbank, E. M. Rains, P. W. Shor, and N. J. A. Sloane. Quantum error correction and orthogonal geometry. Physical Review Letters , 78(3):405–408, 1997. doi:10.1103/ PhysRevLett.78.405

    1997

  3. [10]

    A. R. Calderbank and P. W. Shor. Good quantum error-correcting codes exist. Phys. Rev. A , 54:1098–1105, Aug 1996. doi:10.1103/PhysRevA.54.1098

    1996 doi

  4. [11]

    Chao and B

    R. Chao and B. W. Reichardt. Fault-tolerant quantum computation with few qubits.npj Quantum Information, 4(1):42, 2018. doi:10.1038/s41534-018-0085-z . Accepted in Quantum 2025-08-22, click title to verify. Published under CC-BY 4.0. 32

    2018 doi

  5. [12]

    Chen and N

    Z. Chen and N. Rengaswamy. Tailoring fault-tolerance to quantum algorithms, 2024. arXiv: 2404.11953, doi:10.48550/arXiv.2404.11953

    2024 doi

  6. [13]

    Dehaene and B

    J. Dehaene and B. De Moor. The Clifford group, stabilizer states, and linear and quadratic operations over gf(2). Physical Review A, 68, 04 2003. doi:10.1103/PhysRevA.68.042318

    2003 doi

  7. [14]

    Delfosse and A

    N. Delfosse and A. Paetznick. Spacetime codes of Clifford circuits. 2023. arXiv:2304.05943, doi:10.48550/arXiv.2304.05943

    2023 doi arXiv

  8. [15]

    Dinur, M.-H

    I. Dinur, M.-H. Hsieh, T.-C. Lin, and T. Vidick. Good quantum ldpc codes with linear time decoders. In Proceedings of the 55th Annual ACM Symposium on Theory of Computing , STOC 2023, page 905–918, New York, NY , USA, 2023. Association for Computing Machinery.doi: 10.1145/3564...

    2023

  9. [16]

    A. Dua, A. Kubica, L. Jiang, S. T. Flammia, and M. J. Gullans. Clifford-deformed surface codes. PRX Quantum, 5(1):010347, 2024. doi:10.1103/PRXQuantum.5.010347

    2024 doi

  10. [17]

    Fawzi, A

    O. Fawzi, A. Grospellier, and A. Leverrier. Constant overhead quantum fault tolerance with quantum expander codes. Commun. ACM, 64(1):106–114, Dec. 2020. doi:10.1145/3434163

    2020 doi

  11. [18]

    A. G. Fowler, M. Mariantoni, J. M. Martinis, and A. N. Cleland. Surface codes: Towards prac- tical large-scale quantum computation. Phys. Rev. A , 86:032324, Sep 2012. doi:10.1103/ PhysRevA.86.032324

    2012

  12. [19]

    Gottesman

    D. Gottesman. Stabilizer Codes and Quantum Error Correction . PhD thesis, California Insti- tute of Technology, 1997. arXiv:quant-ph/9705052, doi:10.48550/arXiv.quant-ph/ 9705052

    1997 doi arXiv

  13. [20]

    Gottesman

    D. Gottesman. Theory of fault-tolerant quantum computation. Physical Review A , 57(1):127,

  14. [21]

    Gottesman

    D. Gottesman. An introduction to quantum error correction and fault-tolerant quantum compu- tation. In Quantum Information Science and its Contributions to Mathematics , volume 68 of Proceedings of Symposia in Applied Mathematics , pages 13–58. American Mathematical Soci- ety,...

    2010 doi

  15. [22]

    Gottesman

    D. Gottesman. Fault-tolerant quantum computation with constant overhead. 2014. Published in Quantum Information & Computation, V ol. 14, No. 15–16 (2014), pp. 1338–1372. arXiv: 1310.2984, doi:10.48550/arXiv.1310.2984

    2014 doi arXiv

  16. [23]

    L. C. Grove. Classical Groups and Geometric Algebra, volume 39 of Graduate Studies in Math- ematics. American Mathematical Society, 2002. doi:10.1090/gsm/039

    2002 doi

  17. [24]

    A. Y . Kitaev. Quantum computations: algorithms and error correction. Russian Mathematical Surveys, 52(6):1191–1249, 1997. doi:10.1070/RM1997v052n06ABEH002155

    1997 doi

  18. [25]

    A. Y . Kitaev, A. Shen, and M. N. Vyalyi. Classical and Quantum Computation , volume 47 of Graduate Studies in Mathematics. American Mathematical Society, 2002. doi:10.1090/gsm/ 047

    2002 doi

  19. [26]

    Knill, R

    E. Knill, R. Laflamme, and W. H. Zurek. Resilient quantum computation. Science, 279(5349):342–345, 1998. doi:10.1126/science.279.5349.342

    1998 doi

  20. [27]

    A. A. Kovalev and L. P. Pryadko. Fault tolerance of quantum low-density parity check codes with sublinear distance scaling. Physical Review A, 87(2):020304, 2013. doi:10.1103/PhysRevA. 87.020304. Accepted in Quantum 2025-08-22, click title to verify. Published under CC-BY 4.0. 33

    2013 doi

  21. [28]

    Krishna and D

    A. Krishna and D. Poulin. Fault-tolerant gates on hypergraph product codes. Phys. Rev. X , 11:011023, Feb 2021. doi:10.1103/PhysRevX.11.011023

    2021 doi

  22. [29]

    Leverrier and G

    A. Leverrier and G. Z ´emor. Quantum Tanner codes. In 2022 IEEE 63rd Annual Symposium on F oundations of Computer Science (FOCS) , pages 872–883, 2022. expanded version in arXiv:2202.13641. doi:10.1109/FOCS54457.2022.00117

    2022 arXiv

  23. [30]

    T.-C. Lin. Transversal non-Clifford gates for quantum LDPC codes on sheaves, 2024. arXiv: 2410.14631, doi:10.48550/arXiv.2410.14631

    2024 doi arXiv

  24. [31]

    A. J. Malcolm, A. N. Glaudell, P. Fuentes, D. Chandra, A. Schotte, C. DeLisle, R. Haenel, A. Ebrahimi, J. Roffe, A. O. Quintavalle, et al. Computing efficiently in QLDPC codes. 2025. arXiv:2502.07150, doi:10.48550/arXiv.2502.07150

    2025 doi

  25. [32]

    Martiel and A

    S. Martiel and A. Javadi-Abhari. Low-overhead error detection with spacetime codes. 4 2025. arXiv:2504.15725, doi:10.48550/arXiv.2504.15725

    2025 doi arXiv

  26. [33]

    Maslov and M

    D. Maslov and M. Roetteler. Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations. IEEE Transactions on Information Theory , 64(7):4729–4738, 2018. doi:10.1109/TIT.2018.2825602

    2018

  27. [34]

    Panteleev and G

    P. Panteleev and G. Kalachev. Asymptotically good quantum and locally testable classical ldpc codes. In Proceedings of the 54th Annual ACM SIGACT Symposium on Theory of Computing , STOC 2022, page 375–388, New York, NY , USA, 2022. Association for Computing Machinery. doi:10.1...

    2022

  28. [35]

    Pllaha, N

    T. Pllaha, N. Rengaswamy, O. Tirkkonen, and R. Calderbank. Un-Weyl-ing the Clifford hierar- chy. Quantum, 4:370, December 2020. doi:10.22331/q-2020-12-11-370

    2020 doi

  29. [36]

    Pllaha, K

    T. Pllaha, K. V olanto, and O. Tirkkonen. Decomposition of Clifford gates. In 2021 IEEE Global Communications Conference (GLOBECOM) , pages 01–06, 2021. doi:10.1109/ GLOBECOM46510.2021.9685501

    2021

  30. [38]

    Raussendorf and J

    R. Raussendorf and J. Harrington. Fault-tolerant quantum computation with high threshold in two dimensions. Physical Review Letters, 98(19):190504, 2007. doi:10.1103/PhysRevLett. 98.190504

    2007 doi

  31. [39]

    Rengaswamy, R

    N. Rengaswamy, R. Calderbank, S. Kadhe, and H. D. Pfister. Logical Clifford synthesis for stabilizer codes. IEEE Transactions on Quantum Engineering , 1:1–17, 2020. doi:10.1109/ TQE.2020.3023419

    2020

  32. [40]

    A. Steane. Error correcting codes in quantum theory. Phys. Rev. Letters , 77:793–797, 1996. doi:10.1103/PhysRevLett.77.793

    1996 doi

  33. [41]

    A. M. Steane. Efficient fault-tolerant quantum computing. Nature, 399(6732):124–126, 1999. doi:10.1038/20127

    1999 doi

  34. [42]

    Tillich and G

    J.-P. Tillich and G. Z ´emor. Quantum ldpc codes with positive rate and minimum distance pro- portional to the square root of the blocklength. IEEE Transactions on Information Theory , 60(2):1193–1202, 2014. doi:10.1109/TIT.2013.2292061. Accepted in Quantum 2025-08-22, click t...

    2014

  35. [43]

    M. A. Tremblay, N. Delfosse, and M. E. Beverland. Constant-overhead quantum error cor- rection with thin planar connectivity. Phys. Rev. Lett. , 129:050504, Jul 2022. doi:10.1103/ PhysRevLett.129.050504

    2022

  36. [44]

    M. Wilde. Logical operators of quantum codes. Physical Review A, 79, 03 2009. doi:10.1103/ PhysRevA.79.062322

    2009

  37. [45]

    Q. Xu, H. Zhou, G. Zheng, D. Bluvstein, J. P. B. Ataides, M. D. Lukin, and L. Jiang. Fast and parallelizable logical computation with homological product codes. Phys. Rev. X , 15:021065, May 2025. doi:10.1103/PhysRevX.15.021065

    2025 doi

  38. [46]

    T. J. Yoder, R. Takagi, and I. L. Chuang. Universal fault-tolerant gates on concatenated stabilizer codes. Phys. Rev. X, 6:031039, Sep 2016. doi:10.1103/PhysRevX.6.031039

    2016 doi

  39. [47]

    G. Zhu, S. Sikander, E. Portnoy, A. W. Cross, and B. J. Brown. Non-Clifford and paral- lelizable fault-tolerant logical gates on constant and almost-constant rate homological quan- tum LDPC codes via higher symmetries, 2024. arXiv:2310.16982, doi:10.48550/arXiv. 2310.16982. Ac...

    2024 doi

  40. [50]

    Exchange rows 2 and 5

  41. [51]

    Add row 6 to row 1 and add row 4 to row 3

  42. [52]

    Add row 2 to row 1 and add row 4 to row 5. that is A4A3A1A2A1Fg =I, where A4 =   1 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 0 1   ,A 3 =   1 0 0 0 0 1 0 1 0 0 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1   ,A 2 = ...

    2025

  43. [53]

    For everyy∈ supp(v)\{x}, add rowx to rowy and add row (y +n) to row (x +n)

    Choose x∈ supp(v). For everyy∈ supp(v)\{x}, add rowx to rowy and add row (y +n) to row (x +n)

  44. [54]

    Add row (x +n) to rowx

  45. [55]

    For every y∈ supp(v)\{x}, add rowx to rowy and add row (y +n) to row (x +n). onI2n×2n gives rise to the symplectic matrix: F =   I˜nטn 0˜n× ˜m v⊺v 0˜n× ˜m 0 ˜mטn I ˜m× ˜m 0 ˜mטn 0 ˜m× ˜m 0˜nטn 0˜n× ˜m I˜nטn 0˜n× ˜m 0 ˜mטn 0 ˜m× ˜m 0 ˜mטn I ˜m× ˜m  . Since supp...

    2025

  46. [56]

    For every x,y∈ supp(v),x<y , add row (x +n) to rowy and add row (y +n) to rowx

  47. [57]

    To see that these operations on I2n×2n produce the matrix F , let M = v⊺v and note that it can be written as M = ∑ r∈supp(v) ∑ s∈supp(v)\{r} e⊺ res + ∑ r∈supp(v) e⊺ rer

    For every x∈ supp(v), add row (x +n) to rowx. To see that these operations on I2n×2n produce the matrix F , let M = v⊺v and note that it can be written as M = ∑ r∈supp(v) ∑ s∈supp(v)\{r} e⊺ res + ∑ r∈supp(v) e⊺ rer. It is easy to see that the row operations in Step (1) above p...

  48. [58]

    Recalling the notation of Section 2.3, we see that I is contained in columnh of the left sector. The X stabilizer generator SX(h′,j ) is supported on column h′ of the left sector and row j of the right sector, while theZ stabilizer generatorSZ(i′,l ) is supported on rowi′ of t...

    2025

  49. [59]

    For each x∈ supp(v)\{ρ}, add rowx +n to rowρ and add rowρ +n to rowx

  50. [60]

    For each y∈ supp(u), exchange rwoy and rowy +n

  51. [61]

    For each y∈ supp(u)\{ρ}, add rowy +n to rowρ and add rowρ +n to rowy

  52. [62]

    For each y∈ supp(u), exchange rwoy with rowy +n

  53. [63]

    For each y∈ supp(u)\{ρ}, add rowy to rowρ and add rowρ +n to rowy +n

  54. [64]

    For each x∈ supp(v)\{ρ}, add rowρ to rowx and add rowx +n to rowρ +n

  55. [65]

    Exchange row ρ and rowρ +n. onI2n×2n gives rise to the symplectic matrix F =   I˜nטn +v⊺u 0˜n× ˜m v⊺v 0˜n× ˜m 0 ˜mטn I ˜m× ˜m 0 ˜mטn 0 ˜m× ˜m u⊺u 0˜n× ˜m I˜nטn +u⊺v 0˜n× ˜m 0 ˜mטn 0 ˜m× ˜m 0 ˜mטn I ˜m× ˜m  . Since supp(v), supp(u)⊂ [˜n], i.e., we are operating ...

    2025

  56. [66]

    For all y∈ supp(v)\{x}, add row x to rowy and add row y +n to rowx +n

    Select a row index x∈ supp(v). For all y∈ supp(v)\{x}, add row x to rowy and add row y +n to rowx +n

  57. [67]

    For all ¯y∈ supp(u), add row ¯y + ˜n to rowx and add rowx +n to row ¯y + ˜n +n

  58. [68]

    For all y∈ supp(v)\{x}, add rowx to rowy and add rowy +n to rowx +n. onI2n×2n gives rise to the symplectic matrix F =   I˜nטn v⊺u 0˜nטn 0˜n× ˜m 0 ˜mטn I ˜m× ˜m 0 ˜mטn 0 ˜m× ˜m 0˜nטn 0˜n× ˜m I˜nטn 0˜n× ˜m 0 ˜mטn 0 ˜m× ˜m u⊺v I ˜m× ˜m  . Fix an x in supp(v) and ...

    2025

  59. [70]

    For all ¯y∈ supp(u)\{y}, add rowy to row ¯y and add row ¯y +n to rowy

  60. [71]

    Add row x +n to rowy and add rowy +n to rowx

  61. [72]

    For all y∈ supp(v)\{x}, add rowx to rowy and add rowy +n to rowx +n

  62. [73]

    For all ¯y∈ supp(u)\{y}, add rowy to row ¯y and add row ¯y +n to rowy. Since the operations are completely contained within rows {1,··· , ˜n} and{n + 1,··· ,n + ˜n}, for notational simplicity we consider the restricted matrix F = [ I˜nטn v⊺u +u⊺v 0˜nטn I˜nטn ] . Accepted in...

    2025

  63. [1998]

    doi:10.1103/PhysRevA.57.127

    doi

Pith tools

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