{"id":"a5f9ce9a-50af-4ca0-b4c5-5dc92616741d","arxiv_id":"2507.13496","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":2,"one_line_summary":"Conjoining only bit-flip and phase-flip repetition codes can generate any CSS code, and an iterative algorithm grows sparse subsystem codes with kd^2=O(n) worst-case scaling.","lead":"This paper shows how to build larger quantum error-correcting codes by gluing together tiny two-qubit repetition code blocks, while keeping the error checks sparse. It also gives an iterative algorithm that grows sparse subsystem codes with a guaranteed distance scaling of kd^2=O(n) in the worst case.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The key distance-increase step (Lemma 6) assumes a globally consistent pairing of newly added qubits across all overweight X-checks; the proof only asserts this pairing, and the matrix rule in §4.3 pairs rows independently, so Theorem 1's distance guarantee is not established as written.","rationale":"I read the paper as attempting to establish a general iterative construction: from any sparse CSS-like subsystem seed, repeat concatenation with repetition codes and XN/ZN traces to grow distance while keeping k and Tanner degree bounded. For the central claim to hold, the trace step must reduce every overweight generator simultaneously without ever decreasing any logical operator's minimal weight. That is precisely Lemma 6. My stress-test found that the lemma's proof is a sketch: it asserts that 'distinct pairs' can be chosen for each generator and that bounded qubit degree limits the damage, but it does not prove that the pair choices across overlapping generators are compatible. The concrete matrix rule in §4.3 also processes rows independently, and no argument shows its choices correspond to an actual tensor contraction. This is not a disagreement with known results; it is an internal gap in the proof of Theorem 1, and Theorem 2 inherits it. I have no objection to the examples: surface code, compass, and Bacon-Shor constructions are concrete and likely correct, and Theorem 3's universality is essentially a known ZX-calculus fact (the paper cites [30]). So the overall verdict should remain CONDITIONAL: accept the examples and framework as promising, but require a rigorous global-pairing argument (or a modified algorithm) before the general distance guarantee is accepted. The proposed concrete test (mechanically applying §4.3 to a 2×2 seed) would settle whether the current rule is already inconsistent or whether a compatible pairing always exists in the low-degree cases the paper targets.","tokens_in":137,"tokens_out":10826,"duration_ms":138689,"concrete_test":"Implement the check-matrix transformation of §4.3 for a small CSS-like subsystem seed, e.g. the 2×2 Bacon-Shor code with wX=wZ=2 and qX=qZ=2, using the literal row-by-row pairing rule: for each overweight row in hX choose its first two nonzero added columns, subtract the corresponding wx from all rows sharing both columns, append the weight-2 X-row, and then check (a) all X-row weights ≤ wX, (b) all column X-degrees ≤ qX, and (c) whether the same added column was selected in two different XN pairs. If (c) occurs, the construction as written is not a valid sequence of tensor contractions and Lemma 6's existence claim fails for this seed; if no conflict occurs, recompute the distance of the resulting subsystem code to confirm d_X increased by at least 1. This is a small symplectic-matrix check and directly settles the pairing-consistency assumption.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Theorem 1 rests on Lemma 6: after concatenating supp(¯Z0) with bit-flip codes, every overweight X-gauge generator can be reduced by applying XN to 'distinct pairs' of added qubits, while every logical X operator keeps an odd number of unpaired added qubits, so distance increases by at least 1. The difficulty is global consistency. A newly added qubit can lie in up to qX different X-generators. Reducing one generator may require pairing it with a particular partner, while reducing another overlapping generator may require pairing it with a different partner; a single qubit cannot be consumed by two different XN blocks. The proof says bounded degree limits the number of weight-2 checks, but bounded degree does not by itself resolve conflicting pairings. The algorithm's concrete rule in §4.3 ('Non-isometric trace') processes rows of hX one at a time, picking the first two nonzero entries of each overweight row; nothing guarantees these chosen pairs are disjoint, and the operation 'subtract wx from each row if both entries nonzero' is not shown to be realizable as a tensor contraction when columns overlap across choices. Lemma 6 also asserts without proof that the weight-2 X-checks created by XN are gauge operators and cannot be used (via multiplication) to reduce a logical X operator's weight back to its pre-concatenation value; Table 1 describes single-tensor transformations, not the global effect of many overlapping XN insertions. Since Theorem 2's kd^2=O(n) bound inherits the distance increment from Theorem 1, a gap here propagates to the main asymptotic claim. This is a correctness-risk gap, not an inconsistency: the examples may well work, but the general guarantee is unsupported.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes an iterative procedure for growing sparse CSS-like subsystem codes from a small seed code by alternating ordinary concatenation with 2-qubit bit-flip/phase-flip repetition codes and conjoining with non-isometric [[4,1,2]] tensors (ZN and XN). The main theoretical claims are: (1) Theorem 1, that each iteration increases the distance by at least 1 while preserving the number of logical qubits and the Tanner-graph degree bounds; (2) Theorem 2, that the worst-case asymptotic scaling of the algorithm yields kd^2 = O(n); and (3) Theorem 3, that every CSS code can be built from 2-qubit bit-flip and phase-flip repetition codes by conjoining. The paper also provides explicit tensor-network constructions for the rotated surface code, the 2D compass code, and 2D and 3D Bacon-Shor codes, together with an automated example of a [[684,2,12<=d<=32]] code.","tokens_in":23959,"tokens_out":7264,"duration_ms":88723,"significance":"If the main theorems are correct, the paper offers a genuinely new constructive principle: sparse codes can be grown from small blocks while using non-isometric conjoining to control check weights, something ordinary concatenation cannot do. The examples and the graphical/tensor-network perspective are valuable in themselves, and the explicit algorithm is a useful step toward synthesizing qLDPC-type codes from elementary modules. The paper also gives a concrete falsifiable claim in the form of the reported [[684,2,12<=d<=32]] construction. However, the central distance-increase guarantee is not proved as written: the global pairing step in Lemma 6 is asserted rather than demonstrated, and the asymptotic accounting in the proof of Theorem 2 contains an unjustified quantitative step. These issues are load-bearing and must be repaired before the main claims can be accepted.","major_comments":[{"comment":"Lemma 6 assumes that for each overweight X-generator, the newly added qubits can be partitioned into pairs and that applying XN to each pair reduces the generator weight while leaving the logical structure intact. The actual row operation in §4.3 ('Non-isometric trace') selects the first two nonzero entries of each overweight row independently. Since a newly added qubit can appear in up to q_X distinct X-checks, nothing in the algorithm prevents the same qubit from being chosen in two different pairs, and two XN contractions sharing a qubit cannot be realized as independent tensor contractions. The degree bound limits the number of overlaps but does not by itself imply a globally consistent pairing across all rows. Theorem 1 therefore requires either an explicit matching argument that produces disjoint pairs for all overweight generators simultaneously, or a modified row-reduction rule that is provably equivalent to a sequence of XN conjoinings.","section":"§4.2, §4.3, and Lemma 6 (Appendix A)"},{"comment":"The proof asserts that the weight-2 X-checks introduced by XN are gauge operators and that multiplication by them cannot reduce a logical X operator's weight back to its pre-concatenation value. This is argued from Table 1, which describes a single XN tensor, but the weight-reduction step applies many XN insertions whose gauge qubits can become correlated through overlapping support. The parity argument ('there is no perfect pairing') is applied to the new terms in the generator representation, whereas the distance of a subsystem code is defined modulo the full gauge group, including arbitrary products of the newly introduced gauge checks. A proof that every nontrivial dressed logical X operator retains weight at least d+1 after reduction by the complete gauge group is missing.","section":"Lemma 6 (Appendix A)"},{"comment":"The proof begins with the statement that 'to add to the distance of the first set of logical operators, from Lemma 8 we need to add 2d + c sites.' This quantitative claim is not derived anywhere: Lemma 8 only bounds the increase of the bare logical distance by c, and no lemma establishes that adding 2d+c sites suffices to increase the minimum distance by 1 for all logical operators. The recurrence leading to Eq. (4) and the final asymptotic form [[n'=ckD^2, k'=k, d'=D]] are therefore not established. The claimed scaling bound kd^2=O(n) may be true for the explicit Bacon-Shor examples, but as a theorem about the worst case of the algorithm it needs a rigorous bookkeeping of how the supports of all bare logical operators grow over repeated iterations.","section":"Appendix B, Theorem 2"},{"comment":"Lemma 4 states that concatenating the support of a bare logical Z_j increases the weight of every X-type logical operator acting nontrivially on the j-th logical qubit by at least 1, because such operators must intersect supp(Z_j) at least once. This is correct for bare logical operators, but the statement is applied to 'dressed' logical operators as well. Dressed logical operators can differ from bare ones by gauge operators, and the intersection parity with Z_j may be affected by the gauge part. The proof should state explicitly whether the distance is tracked for bare representatives or for all dressed representatives, and justify the transition in the later steps of the algorithm.","section":"§4.2, Lemma 4"}],"minor_comments":[{"comment":"The description of the matrix rule is incomplete without a proof that the row operation 'subtract w_x from each row of h_x if both entries are nonzero' is equivalent to an actual tensor contraction when rows share columns; a small worked example would greatly improve readability.","section":"§4.3, Non-isometric trace"},{"comment":"The table entries such as 'no change not permitted' are ambiguous; a legend explaining the meaning of the two columns (non-active vs active gauge qubit) and an example for at least one row would make the transformation rules easier to verify.","section":"Table 1"},{"comment":"The statement 'Since any X- or Z-spider can be built from contracting the tensors of two-qubit phase and bit-flip codes' is invoked without a reference or derivation; adding a citation to the ZX-calculus literature or a short explicit construction would make the proof more self-contained.","section":"§5, Theorem 3"},{"comment":"The automated construction of the [[684,2,12<=d<=32]] code is reported without code or a reproducible script; providing the final check matrices or a software artifact would substantially increase confidence in the construction, especially given the gap in the proof of Theorem 1.","section":"§4.5.3"},{"comment":"The paper alternates between 'concatenation' and 'conjoining' without always clarifying which operation is meant; a short paragraph stating that standard concatenation is a restricted case of conjoining and specifying which steps of the algorithm use which operation would help the reader.","section":"Throughout"},{"comment":"There are several typos and infelicities, e.g., 'fault-tolearnt' in the Discussion, 'as after conjoining must have distance' in §3, and 'an abundant supply of them' in the Introduction; these should be corrected in a revision.","section":"Editorial"}],"recommendation":"major_revision","confidential_remarks":"The paper's main contribution is promising, but the proof of the central distance theorem is not rigorous in its current form, and the asymptotic theorem inherits an unjustified step. I would recommend major revision rather than rejection because the underlying idea is plausible and the examples are concrete. The editor may wish to involve a referee familiar with the quantum lego formalism to assess whether the asserted transformation rules and the conjoining operations are fully faithful to the tensor-network picture."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The short version: this is a real construction, not a toy, but the main proof has a genuine gap and the asymptotic claim is oversold. Worth a serious referee.\n\nWhat is new: the iterative seed-growing algorithm for sparse subsystem codes, the non-isometric ZN/XN [[4,1,2]] legos used for weight reduction, and the worked examples — surface code, compass code, 2d and 3d Bacon-Shor codes, and a 684-qubit code with explicitly tracked distance bounds. The check-matrix moves in §4.3 are explicit enough to code up, and the tensor networks for the surface and compass codes are a useful byproduct. The universality theorem overlaps with Kissinger's phase-free ZX result, and the authors acknowledge that; their tensor-network proof is still a clean way to see it.\n\nWhere it gets soft. Theorem 1 rests on Lemma 6, and Lemma 6 assumes you can pair the newly added qubits inside each overweight X-check with a globally consistent set of disjoint pairs. That is exactly where the proof is only asserted. A newly added qubit can participate in up to qX different X-checks; the partner that reduces one check may be needed to reduce another, and a single qubit cannot be consumed by two XN blocks. Bounded degree does not by itself resolve the conflict. The row-by-row rule in §4.3 does not enforce disjointness, and no argument shows the resulting column operations correspond to valid tensor contractions. So Theorem 1's distance guarantee is not established as written. This is a correctness-risk gap, not an inconsistency I can point to in the examples; the examples may well be fine.\n\nTheorem 2 inherits that gap, and it has an independent issue: the \"add 2d+c sites\" step is asserted without derivation. Also, calling kd^2 = O(n) a saturation of the BPT bound is misleading unless the final code is geometrically local; the algorithm as presented doesn't guarantee that. The bound's numerology is identical, but the locality premise is not.\n\nWho this is for: people working on finite-size sparse subsystem codes or tensor-network representations of standard code families. The paper deserves a serious referee. The referee should ask for a real global-pairing lemma, or a modified algorithm that constructs the pairing explicitly. If that gets fixed, Theorem 1 is plausibly true. Until then, I'd treat the general distance guarantee as a conjecture, not a theorem.","headline":"A genuinely new modular construction with nice worked examples, but the main distance theorem has a real global-pairing gap and the asymptotic claim is oversold; worth a serious referee.","tokens_in":24548,"tokens_out":4481,"would_cite":true,"duration_ms":52853,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["81P70","94B05"],"pacs":["03.67.Pp"],"model":"deepseek-v4-flash","headline":"By conjoining only 2-qubit bit-flip and phase-flip repetition codes, the authors show every CSS code can be built and sparse subsystem codes can be grown with distance guaranteed to increase.","keywords":["quantum LDPC codes","subsystem codes","conjoining","quantum lego","repetition codes","CSS codes","tensor networks","code distance"],"falsifier":"Run the algorithm on a small seed such as the [[4,2,2]] code with strict weight caps and compute the true minimum distance of the output; if any round fails to increase distance by 1, or if the resulting [[684,2,12≤d≤32]] example is found to have distance below 12, the central theorem is false.","tokens_in":23397,"feed_emoji":"🧩","tokens_out":4908,"duration_ms":56224,"temperature":0.7,"pith_summary":"The paper tries to establish that sparse quantum codes—codes where every check acts on few qubits and every qubit participates in few checks—can be grown iteratively from tiny seed codes in the same modular spirit as concatenation, without letting check weights blow up. It claims that conjoining just two-qubit bit-flip and phase-flip repetition codes is enough to build any CSS code, and it provides a polynomial-time algorithm that increases code distance by at least one per round while keeping the Tanner graph degree bounded. In the worst case the algorithm produces codes with kd²=O(n), saturating the Bravyi-Poulin-Terhal bound for 2D codes. A sympathetic reader would care because this offers a constructive, modular pathway from simple atomic codes to sparse codes with controlled parameters, a step toward growing quantum LDPC codes with useful fault-tolerant properties.","feed_headline":"Gluing repetition codes builds every CSS code","feed_subtitle":"An iterative algorithm grows sparse subsystem codes with distance guarantee kd²=O(n) from tiny seeds.","key_machinery":"The conjoining operation on check matrices of stabilizer codes, which is the check-matrix version of tensor contraction in the quantum lego formalism, is the central object: two code blocks are glued by identifying legs (qubits), and the resulting stabilizers and logical operators are found by operator matching. The second key object is the non-isometric [[4,1,2]] lego block (ZN for Z-type and XN for X-type), built from spiders or repetition codes, which reduces two-input operators to zero or to gauge operators while preserving single-input weight. This non-isometric trace is what lets check weights shrink during growth, counteracting the weight increase that ordinary concatenation causes. The iterative algorithm combines three moves—concatenation along the support of a bare logical operator, non-isometric trace to lower check weight, and a shifting step that moves Z-checks to newly added qubits to lower qubit degree—and tracks how bare logical operators transform so that the whole process is polynomial in n.","core_discovery":"The central claim is that sparse subsystem codes can be generated by alternating ordinary concatenation with conjoining steps that use non-isometric lego blocks, specifically tensors derived from 2-qubit repetition codes. Theorem 1 states that each round of the algorithm raises the code distance by at least 1 while leaving the number of logical qubits k and the Tanner graph degree unchanged. Theorem 2 states that the worst-case asymptotic scaling of the algorithm produces codes with kd²=O(n), which saturates the Bravyi-Poulin-Terhal bound and is therefore optimal at this level of generality. Theorem 3 states that every CSS code can be built from 2-qubit bit-flip and phase-flip repetition codes through conjoining, showing that these simple atoms are not a limitation on expressivity.","pith_inferences":["The same conjoining-with-bad-codes trick might extend to non-CSS stabilizer codes or qudit codes, since the gauge-qubit decoupling argument does not obviously rely on CSS structure; running the algorithm on a non-CSS seed and checking whether distance and sparsity survive would be a direct test.","The worst-case kd²=O(n) bound reflects the choice of S' = supp of a bare logical operator as the set to concatenate; identifying smaller minimal-intersection sets that meet all minimal-weight logical operators could improve the scaling, possibly toward linear distance.","The repeated use of XN tensors correlates gauge qubits across different non-isometric blocks, and these correlations are only sketched in the paper; whether they can be harnessed for fault-tolerant code switching or fusion-based preparation is an untested direction.","The average-case distance scaling and constant factors are open, and the paper's own [[684,2,12≤d≤32]] example suggests that tracking true minimum distances on generated codes could provide empirical guidance for improving the algorithm."],"forward_implications":["Every CSS code, however complicated, can be realized as a tensor network of the same two atomic blocks, so creative gluing of repetition codes is a universal construction method.","The iterative algorithm yields a concrete polynomial-time procedure for growing sparse subsystem codes with controlled distance, which can be applied to finite-size near-term codes rather than only asymptotic families.","The new tensor-network representations of the surface code, compass code, and 2D and 3D Bacon-Shor codes may enable more efficient tensor contractions, for example in weight-enumerator computations.","Asymmetric distances can be engineered by growing X and Z distances at different frequencies, as stated in Corollary 1.","The method offers an alternative sparsification strategy: instead of sparsifying a prebuilt code, one keeps checks thin as the code grows, which may preserve distance more directly."],"supporting_citations":[{"why":"Introduces the quantum lego formalism and the conjoining operation on check matrices that the entire construction relies on.","marker":"[31]"},{"why":"Shows how repetition-code spiders compose into tensor networks and provides the enumerator framework used to analyze the resulting codes.","marker":"[34]"},{"why":"Provides the analogous graphical proof that phase-free ZX diagrams are CSS codes, which Theorem 3 parallels and extends.","marker":"[30]"},{"why":"Supplies the iceberg code example that motivates the strategy of concatenating with bad codes to reduce check weight.","marker":"[48]"},{"why":"Establishes the baseline for concatenated codes and the control of distance and rate that this work aims to extend to sparse codes.","marker":"[1]"},{"why":"States the Bravyi-Poulin-Terhal bound that Theorem 2's kd²=O(n) scaling saturates.","marker":"[53]"}],"fun_headline_variants":["Conjoining repetition codes grows optimal sparse codes","Quantum seeds: repetition codes generate all CSS codes","From repetition seed to optimal distance sparse codes","Conjoining builds sparse codes that hit kd² bound","Any CSS code from conjoined 2-qubit repetition codes"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The distance guarantee depends on the claim that, after each growth step, the newly added qubits can be paired up consistently for every X-type gauge generator so that applying a weight-reducing tensor to each pair never lets a logical operator hide its new qubits inside gauge operators.","fun_headline_variants_meta":{"raw":{"variants":["Conjoining repetition codes grows optimal sparse codes","Quantum seeds: repetition codes generate all CSS codes","From repetition seed to optimal distance sparse codes","Conjoining builds sparse codes that hit kd² bound","Any CSS code from conjoined 2-qubit repetition codes"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000193,"raw_usage":{"total_tokens":1305,"prompt_tokens":853,"completion_tokens":452,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":469,"completion_tokens_details":{"reasoning_tokens":378}},"tokens_in":469,"tokens_out":452,"duration_ms":5896,"temperature":1.0,"reasoning_tokens":378,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-06T16:25:12.151766+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the algorithm on a small seed such as the [[4,2,2]] code with strict weight caps and compute the true minimum distance of the output; if any round fails to increase distance by 1, or if the resulting [[684,2,12≤d≤32]] example is found to have distance below 12, the central theorem is false.","supporting_citations":[{"cited_title":"Quan- tum lego: Building quantum error correction codes from tensor networks.PRX Quantum, 3(2), May 2022","cited_arxiv_id":null,"evidence_quote":"Introduces the quantum lego formalism and the conjoining operation on check matrices that the entire construction relies on."},{"cited_title":"Gullans, Brad Lackey, and Zitao Wang","cited_arxiv_id":null,"evidence_quote":"Shows how repetition-code spiders compose into tensor networks and provides the enumerator framework used to analyze the resulting codes."},{"cited_title":"Phase-free zx diagrams are css codes (...or how to graphically grok the surface code), 2022","cited_arxiv_id":null,"evidence_quote":"Provides the analogous graphical proof that phase-free ZX diagrams are CSS codes, which Theorem 3 parallels and extends."},{"cited_title":"Protecting expressive circuits with a quantum error detection code","cited_arxiv_id":null,"evidence_quote":"Supplies the iceberg code example that motivates the strategy of concatenating with bad codes to reduce check weight."},{"cited_title":"Tradeoffs for reliable quantum in- formation storage in 2d systems","cited_arxiv_id":null,"evidence_quote":"States the Bravyi-Poulin-Terhal bound that Theorem 2's kd²=O(n) scaling saturates."}],"review_version":1}