{"id":"c891196b-7922-4ab1-9a5f-4cc993d41d66","arxiv_id":"2411.17050","paper_version":3,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"Targeted logical Clifford gates for any hypergraph product code can be built from simple physical gates with support and depth Θ(√n), without ancillas.","lead":"This paper gives explicit circuits that perform logical Clifford operations, such as CNOT and Hadamard, on quantum data encoded in hypergraph product codes. The circuits use only simple gates, touch only about the square root of the code length qubits, and need no extra helper qubits.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The Θ(√n) targeted-Clifford construction rests entirely on the imported SLT-basis theorem (Thm 4.2 from [37]); a direct verification on random HGP codes is needed.","rationale":"The paper's central claim is an existence statement for ancilla-free Clifford circuits with Θ(√n) support and depth for arbitrary HGP codes. The entire constructive mechanism in Section 4 is built on the basis structure supplied by Theorem 4.2 from [37]. This is the single most load-bearing assumption: without the SLT bases and the |X_i∩Z_j|=δ_ij property, the logical Pauli supports can overlap in uncontrolled ways (breaking the CNOT and CZ algorithms) and the weight bounds |a_i|=Θ(√n) have no basis. The paper gives no proof or sketch of this import, and the concluding remarks even contain a related misattribution about which theorem assumes pointwise stabilizer fixing, suggesting the authors' own summary of the assumptions is not fully reliable. The reader's weakest_assumption identifies exactly this dependence, and I agree. However, this is not an identified contradiction or an internal inconsistency: [37] is a published source, and the SLT-basis construction is plausibly standard. The correct disposition is therefore to keep the reader's CONDITIONAL verdict, strengthened by a concrete numerical/algorithmic verification that would settle whether the import holds in the needed form. No other concern—lack of fault tolerance, absence of code, the small depth-count discrepancy in Theorem 4.6, or the concluding misattribution—threatens the central claim as directly as the unverified basis theorem.","tokens_in":39792,"tokens_out":40241,"duration_ms":363200,"concrete_test":"Generate a random small HGP code with good constituent codes (e.g., n_a=n_b=7 or 15 with k,d linear in the block length), compute RREF/SLT bases for the four kernels, and verify |X_i∩Z_j|=δ_ij for the induced logical Pauli bases. Then simulate Algorithms 1–4 in a stabilizer simulator (e.g., Stim or a symplectic Python implementation) and check that each circuit implements the claimed logical Phase, Hadamard, CNOT, or CZ on the logical Pauli group and preserves all stabilizer generators with phase. Any failure of the support-intersection check or of the simulated logical action would invalidate the Section 4 construction for arbitrary HGP codes.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Every support-size, disjointness, and Θ(√n) claim in Section 4 depends on Theorem 4.2, imported from [37], which asserts the existence of SLT bases for ker(H_a), ker(H_a^⊺), ker(H_b), ker(H_b^⊺) with the property that the induced logical Pauli bases satisfy |X_i∩Z_j|=δ_ij. The paper neither proves this theorem nor states its precise hypotheses. The normalization 'the pivot of a_i is i' is used critically: in Theorem 4.8(a) the claimed emptiness of supp(Z_control)∩supp(X_target) for distinct logical qubits follows only if a_{i'} is zero at every other pivot coordinate i, and in Theorem 4.10 the choices x∈I1\\I2, x̄∈I2\\I1 and the phase analysis use the same property. If [37]'s SLT notion is weaker than this 'zero at other pivots' condition, or if its existence proof carries hidden assumptions (e.g., full-rank parity-check matrices or a restricted code family), the symplectic row operations and the Θ(√n) bounds in Theorems 4.4, 4.6, 4.8, and 4.10 can fail for genuinely arbitrary HGP codes. Since the manuscript cites rather than reproduces the basis construction, the central claim is exactly as secure as that import.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","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.","tokens_in":40000,"tokens_out":15788,"duration_ms":140005,"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":[{"comment":"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.","section":"Definition 4.3 (Section 4.1)"},{"comment":"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.","section":"Theorem 4.2 (Section 4.1)"}],"minor_comments":[{"comment":"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.","section":"Theorem 4.4 proof"},{"comment":"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.","section":"Theorem 4.8 proof"},{"comment":"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|).","section":"Theorem 4.6 proof"},{"comment":"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.","section":"Abstract and Section 4.2"},{"comment":"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.","section":"Section 4.2.5 and Figure 2"},{"comment":"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.","section":"Throughout"}],"recommendation":"major_revision","confidential_remarks":"The central risk to the paper's main claim is the unverified import of the SLT-basis theorem. I recommend that the editor require the authors to either reproduce the proof of Theorem 4.2 or state its exact hypotheses from [37], and to correct Definition 4.3, before the paper can be considered fully supported. The rest of the construction, including the appendices, appears solid conditional on that basis theorem."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Here's my take on Patra and Barg. The paper is solid and genuinely useful. The headline: it gives explicit ancilla-free Clifford circuits for targeted logical Phase, Hadamard, CNOT, and CZ on every logical qubit of any hypergraph product code, with Θ(√n) support and depth. That's a real improvement over prior work, which either handled only symmetric subclasses with transversal/global gates or paid O(n) ancillas for teleportation.\n\nWhat I found new and worth crediting: the symplectic-transvection framework in Sec 3 is clean. Deriving the logical Clifford generators as transvections parametrized by the logical Pauli basis is elegant, and it generalizes to any CSS code. The specialization to HGP codes uses the product structure to turn those transvections into explicit row-operation sequences, and the appendices actually verify the algebra, including the Pauli corrections that fix stabilizer phases. That is reproducible, careful work. The toric code example helps.\n\nSoft spots, in proportion. The main one is the reliance on Theorem 4.2 from [37]: the SLT-basis construction with the support-intersection property |X_i ∩ Z_j| = δ_ij. The paper does not re-prove it or state its precise hypotheses, and all the Θ(√n) bounds and the disjointness arguments in Thms 4.4–4.10 rest on it. The stress-test note is right that if [37]'s SLT notion is weaker than the 'zero at other pivots' condition used here, some steps would need repair. I don't think this is a load-bearing flaw—it's a standard type of basis choice—but the authors should have spelled out the imported theorem rather than citing it. A referee should check that. Everything else is minor: a few depth formulas are off by additive constants, and the concluding remarks misattribute the pointwise-stabilizer assumption to Theorem 3.12; that assumption belongs to Theorem 3.5.\n\nThe paper does not claim fault tolerance, and it doesn't ship code or numerics; for a theoretical construction paper that's fine. The math is parameter-free and the central argument holds up.\n\nBottom line: this is a paper for people designing logical gates for qLDPC codes, and it deserves a serious referee. I'd engage with it, and I'd want the SLT-basis import checked before signing off on the Θ(√n) guarantees.","headline":"Explicit ancilla-free targeted Clifford circuits for any HGP code, with a solid framework and a manageable dependency on an imported basis theorem.","tokens_in":40564,"tokens_out":3723,"would_cite":true,"duration_ms":36307,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["81P68","94B05"],"pacs":["03.67.Pp"],"model":"deepseek-v4-flash","headline":"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).","keywords":["hypergraph product codes","logical Clifford gates","quantum LDPC codes","symplectic matrices","CSS codes","circuit synthesis","toric code","fault-tolerant quantum computing"],"falsifier":"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.","tokens_in":39528,"feed_emoji":"⚛️","tokens_out":11129,"duration_ms":106294,"temperature":0.7,"pith_summary":"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.","feed_headline":"Ancilla-free logical gates for all hypergraph product codes","feed_subtitle":"Targeted Phase, Hadamard, CNOT, and CZ gates run on Θ(√n) qubits with Θ(√n) depth.","key_machinery":"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.","core_discovery":"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.","pith_inferences":["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."],"forward_implications":["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."],"supporting_citations":[{"why":"Supplies the strongly lower triangular bases that make logical X and Z supports intersect in exactly one qubit, the structural input on which all Section 4 circuits rely.","marker":"[37]"},{"why":"Provides the description of logical Pauli operators for HGP codes as line-supported operators (Lemma 4.1), which fixes where the circuits act.","marker":"[28]"},{"why":"Defines hypergraph product codes and their parameters, including k=Θ(n) and d=Θ(√n), which set the scaling claims.","marker":"[42]"},{"why":"Gives the symplectic representation of logical Clifford operators and the framework for converting symplectic matrices into circuits, adapted in Section 3.","marker":"[39]"},{"why":"Shows how to decompose symplectic matrices into elementary Clifford operations, the dictionary behind the circuit-building algorithms.","marker":"[13]"},{"why":"Baseline for targeted logical Clifford gates: previous approach teleports logical qubits out of the code using about 2n ancillas, which this work avoids.","marker":"[45]"}],"fun_headline_variants":["Ancilla-free Clifford gates for all HGP codes","Targeted logical Clifford gates, zero ancillas","HGP codes: full Clifford group with O(√n) depth"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"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.","fun_headline_variants_meta":{"raw":{"variants":["Ancilla-free Clifford gates for all HGP codes","Targeted logical Clifford gates, zero ancillas","HGP codes: full Clifford group with O(√n) depth"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000817,"raw_usage":{"total_tokens":3523,"prompt_tokens":837,"completion_tokens":2686,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":453,"completion_tokens_details":{"reasoning_tokens":2632}},"tokens_in":453,"tokens_out":2686,"duration_ms":19138,"temperature":1.0,"reasoning_tokens":2632,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-12T12:34:44.268917+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"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.","supporting_citations":[],"review_version":1}