{"id":"f9d666d8-d877-414e-b6fd-6b3c939c441f","arxiv_id":"2509.09779","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":7.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":0,"one_line_summary":"Depth-d local encoding circuits for the rotated surface code, built from depth-2 growth steps, with a proof that any inductive construction needs depth d+O(1).","lead":"This paper presents new encoding circuits for the rotated surface code that use only nearest-neighbor gates on a square grid and achieve depth d, halving the previous best of 2d. The construction grows the code stepwise from distance d to d+2, and the paper proves that this growth step is optimal for inductive circuits.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The depth-d construction is asserted from diagrams without a stabilizer-propagation proof; correctness of the purple-repeat growth pattern for arbitrary d is the least secure link in the headline claim.","rationale":"The reader's conditional verdict is appropriate. The construction is credible and the small cases are checkable, but the paper gives no explicit proof that the parametrized growth patterns in Fig. 2 are valid encoders for every distance. That is exactly the assumption on which the headline 'depth d encoding circuits' rests, so the risk of a hidden failure at some larger d is the central correctness risk. The lower-bound proof in Sec. III is likewise terse: the claim that any basis of stabilizers contains at most 2(d+1) two-qubit stabilizers is asserted without derivation, and it is necessary for the depth-at-least-two lower bound. I do not see an internal inconsistency or a direct counterexample; the gaps are missing arguments rather than identified errors. The paper's positive evidence includes explicit small circuits, interactive Crumble links, and a clear construction rule, and the claimed improvement over the previous depth-2d circuits is plausible. A computational sweep over a range of d plus, ideally, an inductive stabilizer-propagation proof would close the gap. The verdict should remain CONDITIONAL, not because the result is likely wrong, but because the central claim is not yet fully established in written form.","tokens_in":4225,"tokens_out":24922,"duration_ms":190829,"concrete_test":"Generate the growth circuit from the textual purple-repeat rule for all relevant d up to, say, 31 (odd and even separately) using Stim/Crumble, apply it to the stabilizer group of the distance-d rotated surface code, and verify that the output stabilizer group and logical operators match the standard distance-(d+2) rotated surface code, including that the logical X and Z operators have weight d+2. If any d fails, the infinite family is falsified; if all pass, write the missing inductive stabilizer-propagation proof to settle the claim for all d.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The paper's central result is an infinite family of encoding circuits, but the correctness of the family is carried entirely by visual pattern description: Fig. 2 shows d=3→5 and d=4→6, and the text says to repeat (or eliminate) the purple-highlighted qubits for other d. No written stabilizer-propagation argument or induction shows that the depth-2 growth circuit maps the stabilizer group of the distance-d rotated surface code to that of the distance-(d+2) code for every d. The interactive Crumble links verify only small instances; they do not certify arbitrary d. If the repeating pattern produces a boundary/corner clash or does not close the stabilizer group for some d, the claimed depth-d circuit does not exist as stated. The lower-bound proof in Sec. III also contains an unproven structural assertion: 'every basis of stabilizers of a (d+2) surface code has at most 2(d+1) two-qubit stabilizers.' This fact is needed to rule out depth-1 growth, so the optimality claim has a second unverified step. Between the two, the construction correctness is the more load-bearing concern because it underpins the main contribution of the paper.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper proposes a family of low-depth encoding circuits for the rotated surface code on a square lattice with nearest-neighbor gates. The construction is inductive: small base codes of distance 2 or 3 are encoded with short circuits, and then depth-2 growth circuits increase the distance from d to d+2. For even d the total depth is d; for odd d it is d+1. The paper also proves a lower bound stating that any inductive encoder built from d to (d+1) or d to (d+2) growth steps must have depth d+O(1), and it compares resource counts with the previous depth-2d circuit of Higgott et al. (2021).","tokens_in":4488,"tokens_out":3971,"duration_ms":35136,"significance":"If the proposed infinite family of growth circuits is correct for all distances, the paper achieves a genuine improvement over the best known 2D local surface-code encoders, halving the depth and reducing the gate count. The lower bound, if fully established, would show that this depth is optimal within the specified inductive class, which is a meaningful but restricted notion of optimality. The paper is clearly written and the small instances are verified with the interactive Crumble tool, which provides useful evidence for those finite cases. The main value of the paper depends on two unproven technical assertions, so the significance is conditional on those being resolved.","major_comments":[{"comment":"The construction of the infinite family of growth circuits is not proved. The text states that for d>4 one repeats the two purple-highlighted qubits and for d=2 one removes them, but it does not provide a written stabilizer-propagation argument or an induction showing that the depth-2 circuit maps the stabilizer group of the distance-d rotated surface code to that of the distance-(d+2) code for every d. The Crumble interactive links verify only finitely many small instances and cannot certify arbitrary distance. Since the headline claim of a depth-d encoding circuit rests entirely on this family, a rigorous proof of correctness is required, including boundary and corner cases.","section":"Sec. II, Fig. 2"},{"comment":"The lower-bound proof relies on the assertion that 'every basis of stabilizers of a (d+2) surface code has at most 2(d+1) two-qubit stabilizers and no single-qubit stabilizers,' but no proof or citation is given. This assertion is load-bearing: it is the only step that rules out a depth-one d to (d+2) growth circuit. Without a proof, the claimed optimality of depth d+O(1) for inductive encoders is not established. The authors should either prove this stabilizer-basis statement or provide a precise reference.","section":"Sec. III"},{"comment":"The abstract claims 'depth d encoding circuits,' but Sec. II states that the total circuit depth is d + [d mod 2], which equals d+1 for odd d. For example, the d=3 base circuit has depth 4, so the claim 'depth d' is literally false for odd distances. The abstract should be corrected to state the depth as d+O(1) or as d+[d mod 2].","section":"Abstract and Sec. II"}],"minor_comments":[{"comment":"The notation [d mod 2] is nonstandard and could be confused with an integer part or floor; please define it explicitly or replace it with (d mod 2).","section":"Sec. II"},{"comment":"The gate counts '6d+O(1)' and '8d+O(1)' are stated without specifying whether the base encoding circuits are included; please clarify the counting convention.","section":"Sec. I"},{"comment":"The figures are dense and the legend for the purple-highlighted qubits is minimal; adding a panel that explicitly shows the repeating pattern for a larger d (e.g., d=5 to d=7 or d=6 to d=8) would improve readability, especially for the boundary and corner regions.","section":"Sec. II, Fig. 2"},{"comment":"The sentence 'Previous work on unitary circuits likely did not discover our low-depth construction because Crumble was not available at the time' is speculative and not relevant to the technical content; please remove or rephrase.","section":"Sec. II"}],"recommendation":"major_revision","confidential_remarks":"The paper is short and the proposed circuits are potentially significant, but the central construction is not actually proven for arbitrary distance and the optimality proof contains an unproven structural assertion. Both are fixable in principle, so major revision is appropriate. If the stabilizer-basis assertion turns out to be false, the lower-bound section would need substantial rework."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Jahan has a real improvement here: depth-d local encoding circuits for the rotated surface code, halving the best previous 2d, with a new inductive growth step. That is a legitimate new construction, and the lower bound for inductive circuits is also new. The paper is honest that the inductive framework comes from [19]. If the construction is right, it's the best known local encoder, useful for magic state injection and topological state preparation.\n\nThe soft spot is exactly where the stress-test put it: the infinite family of growth circuits is described by Figure 2 with instructions to repeat or remove purple qubits, and there is no written stabilizer-propagation proof that the depth-2 circuit maps the d-code stabilizers to the d+2 code for every d. The Crumble links are nice but they verify small instances, not arbitrary d. This is a real gap in the manuscript. It may well be fillable, but as written the central claim rests on diagrams.\n\nThe lower-bound proof in Section III has a second, smaller gap: it asserts without proof that every basis of stabilizers of a (d+2) surface code has at most 2(d+1) two-qubit stabilizers. That claim is plausible and probably easy to prove, but it's load-bearing for the depth-2 lower bound.\n\nNone of this looks like a broken result. The construction is concrete, the gate counts are explicit, and the lower bound is at least stated precisely. The paper deserves a serious referee. My suggestion: send it out, but ask the referee to push for a written correctness argument for the growth family and a proof of the stabilizer-count assertion. If those are supplied, this is a solid constant-factor advance.","headline":"Genuine depth-d encoding family with a real proof gap in the arbitrary-d correctness of the growth pattern.","tokens_in":4948,"tokens_out":1534,"would_cite":true,"duration_ms":308559,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["81P68"],"pacs":["03.67.Pp"],"model":"deepseek-v4-flash","headline":"This paper constructs depth-d encoding circuits for the rotated surface code on a square grid with nearest-neighbor gates, halving the depth of the best previous local encoder and proving that no composition of growth steps can beat it.","keywords":["surface code","encoding circuit","circuit depth","nearest-neighbor connectivity","rotated surface code","Clifford circuits","stabilizer codes","quantum error correction"],"falsifier":"Run a classical stabilizer simulation of the tiled growth circuit for $d=7$, starting from the distance-3 base code and applying the odd-distance growth step twice, and check that the output stabilizer group is exactly that of a distance-7 rotated surface code and that logical operator weights reach 7; any mismatch at this or a larger distance falsifies the inductive claim.","tokens_in":4031,"feed_emoji":"⚛️","tokens_out":13001,"duration_ms":105779,"temperature":0.7,"pith_summary":"This paper gives a concrete way to encode arbitrary qubit states into a rotated surface code of distance $d$ using only nearest-neighbor two-qubit gates on a square grid, with circuit depth $d+[d\\bmod 2]$ (that is, depth $d$ for even $d$ and depth $d+1$ for odd $d$). The previous best local encoder needed depth $2d$, so the new construction roughly halves the time cost of state injection on hardware with 2D local connectivity. The circuit is built by starting from a small distance-2 or distance-3 encoder and repeatedly applying a depth-2 step that grows the code from distance $d$ to distance $d+2$. The paper also proves that any encoder assembled from such growth steps needs depth at least $d+O(1)$, so this design pattern is optimal within its class. If the construction is correct, it lowers the cost of preparing surface-code states for fault-tolerant computing and for realizing topological order without mid-circuit measurement.","feed_headline":"Surface-code encoding in depth d, half the previous best","feed_subtitle":"The new encoder uses only nearest-neighbor square-grid gates and no inductive construction can beat its depth.","key_machinery":"The carrier of the construction is a pair of depth-2 growth circuits, drawn for $d=3\\to5$ and $d=4\\to6$, in which a repeated patch of qubits is tiled to reach arbitrary $d$. Each growth step prepares $4(d+1)$ fresh qubits and entangles them with the existing code so that the stabilizer group expands from distance $d$ to distance $d+2$. The optimality argument is a counting argument over stabilizer weights: before a growth step the fresh qubits carry $4(d+1)$ independent single-qubit stabilizers, a depth-one circuit can only spread each into a one- or two-qubit operator, but a distance-$(d+2)$ surface code has no single-qubit stabilizers and at most $2(d+1)$ two-qubit stabilizers in any basis, so a depth-one growth step is impossible.","core_discovery":"The central discovery is a family of Clifford circuits that encode a rotated surface code of distance $d$ in depth $d+[d\\bmod 2]$ on a square grid with only nearest-neighbor gates, using $6d+O(1)$ two-qubit gates. The construction is inductive: a depth-4 circuit encodes the distance-3 base code, a depth-2 circuit encodes the distance-2 base code, and then two patterned depth-2 circuits—one for odd and one for even $d$—insert $4(d+1)$ fresh qubits and grow the code from distance $d$ to $d+2$. The paper further proves that any Clifford circuit achieving such a growth step needs depth at least two, because a depth-one layer cannot transform $4(d+1)$ independent single-qubit stabilizers into the stabilizer structure of a distance-$(d+2)$ surface code, which has no single-qubit stabilizers and at most $2(d+1)$ two-qubit stabilizers in any basis. Consequently every inductively built encoder must have depth $d+O(1)$, making the new circuits depth-optimal within that framework.","pith_inferences":["The stabilizer-counting argument may transfer to other topological CSS codes: any growth process that adds $m$ fresh qubits and ends in a code whose stabilizer bases contain fewer than $m$ two-qubit generators would inherit the same depth-two lower bound.","The proof does not rule out non-inductive encoders, so a sub-linear-depth local encoding circuit remains a logical possibility; a natural next step is to search for one using interactive circuit construction tools similar to those that enabled this design.","Since the even-distance base case is only depth 2 and each growth step adds a constant depth per two distance units, the parity constant in $d+[d\\bmod 2]$ is already fixed; the remaining slack is only in the constant $O(1)$ term, which could be probed by optimizing the distance-3 base encoder."],"forward_implications":["State injection for the rotated surface code becomes roughly half as deep as with the previous best local encoder, reducing the time window in which physical errors can accumulate during encoding.","The circuit runs on a square grid with only nearest-neighbor coupling, so it matches the connectivity of common two-dimensional qubit arrays without requiring diagonal interactions.","The gate count drops from $8d+O(1)$ to $6d+O(1)$, lowering the number of physical entangling operations per encoding round.","Any future encoder that beats depth $d+O(1)$ must abandon the strategy of composing small distance-growth steps, since this paper shows that class of constructions is already optimal up to constants.","The same circuits can serve as the state-preparation stage for magic-state cultivation and for realizing topologically ordered states without mid-circuit measurement."],"supporting_citations":[{"why":"This is the previous best local encoding circuit, with depth $2d$ and $8d+O(1)$ gates, which the new construction improves on.","marker":"[19]"},{"why":"This reference, together with [19], gives the current best 2D local surface-code encoders using nearest-neighbor and diagonal connectivity.","marker":"[20]"},{"why":"This reference establishes the linear lower bound on depth for any 2D local surface-code encoder.","marker":"[14]"},{"why":"This reference provides an alternative depth-4 encoding circuit for the distance-3 base case used as a starting point for odd distances.","marker":"[18]"}],"fun_headline_variants":["Surface-code encoding depth halved to d","Depth-optimal surface code encoding in d layers","Inductive surface code encoder hits depth d","Surface code encoding shrinks from 2d to d","New surface code circuits: depth d, optimal"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The construction assumes without a written proof that the growth pattern drawn for small distances continues to produce a valid encoding circuit when the marked qubits are repeated to any larger distance; if that pattern fails at some distance, the depth-$d$ result loses its foundation.","fun_headline_variants_meta":{"raw":{"variants":["Surface-code encoding depth halved to d","Depth-optimal surface code encoding in d layers","Inductive surface code encoder hits depth d","Surface code encoding shrinks from 2d to d","New surface code circuits: depth d, optimal"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000168,"raw_usage":{"total_tokens":1229,"prompt_tokens":884,"completion_tokens":345,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":500,"completion_tokens_details":{"reasoning_tokens":274}},"tokens_in":500,"tokens_out":345,"duration_ms":3095,"temperature":1.0,"reasoning_tokens":274,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-15T15:58:33.761935+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run a classical stabilizer simulation of the tiled growth circuit for $d=7$, starting from the distance-3 base code and applying the odd-distance growth step twice, and check that the output stabilizer group is exactly that of a distance-7 rotated surface code and that logical operator weights reach 7; any mismatch at this or a larger distance falsifies the inductive claim.","supporting_citations":[{"cited_title":"Higgott, M","cited_arxiv_id":null,"evidence_quote":"This is the previous best local encoding circuit, with depth $2d$ and $8d+O(1)$ gates, which the new construction improves on."},{"cited_title":"Quantum circuits for toric code and X-cube fracton model","cited_arxiv_id":"2210.01682","evidence_quote":"This reference, together with [19], gives the current best 2D local surface-code encoders using nearest-neighbor and diagonal connectivity."},{"cited_title":"Bravyi, M","cited_arxiv_id":null,"evidence_quote":"This reference establishes the linear lower bound on depth for any 2D local surface-code encoder."},{"cited_title":"A Unitary Encoder for Surface Codes","cited_arxiv_id":"2506.04084","evidence_quote":"This reference provides an alternative depth-4 encoding circuit for the distance-3 base case used as a starting point for odd distances."}],"review_version":2}