{"id":"d0102621-cbb1-467b-935f-e09b910c25ac","arxiv_id":"2501.16827","paper_version":1,"verdict":"REJECT","confidence":"MODERATE","novelty_score":5.0,"correctness_risk":"high","formal_verification":"none","parameter_count":2,"one_line_summary":"Quantum XYZ cyclic codes are constructed with repetition-code structure under pure Pauli noise, but the claimed growing code distance rests on Monte Carlo upper bounds rather than a proof.","lead":"A new family of quantum XYZ cyclic error-correcting codes is introduced, with claimed 50% thresholds under pure Pauli noise and about 13% under depolarizing noise. The main claim that code distance grows with code length is not proven, because only upper bounds are given for the Y and Z logical operators.","discovery_kind":"extension","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The central distance-growth claim rests on unproved lower bounds: logical-Z distance is left open in Sec. V, and Proposition 5 provides only an upper bound for logical-Y, so Table I's dZ/dY values cannot certify the code distance.","rationale":"I agree with the reader's identification of the weakest assumption: the entries labeled dX, dZ, dY in Table I are treated as exact code distances, but Algorithm 1 only furnishes upper bounds from FDBP-OSD trials, and Proposition 5 is an explicit upper bound for dY. The manuscript itself, in Sec. V, states that a strict proof that dZ grows is open and that no proof rules out Y-logical operators below dupY. Because the main claimed advantage over prior cyclic codes is distance growth, and because d = min(dX,dY,dZ), the central claim is not established. I would not downgrade the valid partial contributions: the Abelianness and dimension proofs (Propositions 1-2), the repetition-structure conditions (Proposition 3), and the exact dX construction for a special parameter family are nontrivial and internally consistent. However, they do not close the Y and Z lower-bound gap. The concern is not disagreement with consensus; it is an internal gap explicitly acknowledged by the authors. Since the reader already rejected on this basis, the verdict should remain unchanged. A small exact-distance computation on the first few Table I codes would be a decisive check.","tokens_in":20340,"tokens_out":4501,"duration_ms":42148,"concrete_test":"Compute the exact minimum distance for the smallest rows of Table I (e.g., b=0,a=5,N=17; b=1,a=8,N=25; b=2,a=13,N=37) by exhaustive enumeration or an integer-programming formulation of the stabilizer code's binary parity-check matrix H from Eqs. (12)-(13). Specifically, search for any non-trivial logical operator of Pauli weight below the Table I values dZ and dY; if one exists, the table values are upper bounds and the distance-growth/overhead claims fail for those codes. These sizes are small enough to certify exactly, and the result would settle whether the missing lower-bound proofs are a genuine gap or just an exposition issue.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The paper's novelty claim is that d(C(a,b)) grows with code length. For a stabilizer code, d = min(dX,dZ,dY). Proposition 4 gives an exact dX only for the special sequence a = 2l(b+2)+l-1. Proposition 5 (Eq. 33) is explicitly an upper bound on dY, not a lower bound, and no lower bound for dZ is proved; Sec. V lists both as open questions. Algorithm 1 (Sect. II D) returns upper bounds via a heuristic decoder, so the dZ and dY entries in Table I and Fig. 1 are not established as exact minimum weights. A smaller Y- or Z-logical operator than reported would make the true distance smaller than 2b+5 (or 2b+3), breaking the claimed growth and invalidating the overhead comparison in Fig. 2. The paper's own Sec. V acknowledges the missing proofs, so the strongest claim is not supported by the derivation.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The manuscript introduces a family of [[N,1,d]] quantum XYZ cyclic codes C(a,b), with N = 2(a+b)+7 and stabilizer generators obtained by cyclic shifts of a weight-six XZYYZX-type operator. It proves that the stabilizer group is Abelian (Prop. 1), derives a code-dimension criterion (Prop. 2), gives conditions for repetition-code structure under pure X, Y, or Z noise (Prop. 3), derives an exact logical-X weight for a special parameter subsequence (Prop. 4), and derives an upper bound on logical-Y weight (Prop. 5). It then uses FDBP-OSD Monte Carlo simulations to estimate logical-operator weights and reports code-capacity thresholds of about 50% for pure Pauli noise, about 13% for depolarizing noise, and about 49% for Z-biased noise (eta_Z = 1000), together with a physical-overhead comparison against the XZZX surface code. The paper claims that this is the only known family of quantum cyclic codes whose code distance increases with code length.","tokens_in":20548,"tokens_out":8246,"duration_ms":70830,"significance":"If fully substantiated, the code family would be of interest: it combines a cyclic stabilizer construction with repetition-code behavior under biased Pauli noise, and the reported thresholds would be competitive for biased-noise architectures. The proof of repetition structure (Prop. 3) is a genuine strength, and the 50% thresholds follow cleanly from that structure. The 13% and 49% thresholds are simulation results and require full simulation details for evaluation. However, the paper's central novelty claim—that the true code distance grows with code length—is not established by the present arguments. The obstacles are not minor presentation issues but missing lower bounds on logical Y and Z weights, explicitly acknowledged by the authors in Section V.","major_comments":[{"comment":"The central claim that d(C(a,b)) grows with code length is not proved. For a stabilizer code, d = min(dX, dY, dZ). Proposition 4 establishes dX = 2l+1 only for the special subsequence a = 2l(b+2)+l-1. Proposition 5 (Eq. (33)) explicitly provides only an upper bound on dY. No lower bound for dZ is given, and no proof excludes logical-Y operators below the upper bound; Section V lists both as open questions. The sentence in Section III C stating that these results 'indicates the code distance ... can increase with code length by increasing b' is therefore not a logical consequence of the proved statements.","section":"III C; Propositions 4-5; Section V"},{"comment":"The dY and dZ values in Table I and Fig. 1 are upper bounds generated by a heuristic Monte Carlo procedure, not certified minimum distances. Section II D explicitly describes Algorithm 1 as a method for determining an upper bound on code distance, and FDBP-OSD is not a maximum-likelihood decoder. Thus the 'optimal code' definition in Section IV B, which assumes distance equal to 2b+5 or 2b+3, and the overhead comparison in Fig. 2 rest on unproven distance values. If there exists a logical Y or Z operator of weight smaller than the tabled value, the true distance is smaller than reported and the growth and overhead conclusions may fail.","section":"II D; Algorithm 1; Table I; Fig. 1"},{"comment":"The numerical evidence in Fig. 1 shows that for fixed b the dY estimate saturates at a constant (2b+5 for b=3) while dX and dZ estimates grow with a. Therefore the code distance cannot grow merely by increasing a; the growth claim necessarily relies on increasing b as well. But in that b-growth regime, the missing lower bounds for Y and Z described in the previous comments are exactly the needed ingredients. The numerical upper bounds do not fill that proof gap.","section":"IV A; Fig. 1"}],"minor_comments":[{"comment":"The reference placeholder '[refs]' in the first paragraph is unresolved and should be completed.","section":"Section I"},{"comment":"The procedure for selecting the 'optimal' a for each b is not reproducible as stated: the number of Monte Carlo trials T, FDBP-OSD parameters, and stopping criteria are not specified.","section":"IV B; Table I"},{"comment":"The XZZX surface-code data used in the overhead comparison should be specified in detail, including code sizes, distances, and how those distances are computed, so that the comparison is fair.","section":"IV B; Fig. 2"},{"comment":"The text contains several grammatical errors, including 'These results indicates' (Section III C), 'simultaneusly' (Section IV B), and 'don't have' in Corollary 1; these should be corrected.","section":"III C; IV B; Corollary 1"},{"comment":"The claim that this is the only family of quantum cyclic codes with code distance increasing with code length should either be supported by a systematic literature comparison or be softened, given that the present evidence for distance growth is partly numerical and partly based on upper bounds.","section":"Abstract; Section V"}],"recommendation":"reject","confidential_remarks":"To the editor: the advertised novelty of the paper is the distance-growth claim, yet Section V explicitly leaves the necessary lower-bound proofs open, and the distance values in the main tables are produced by the authors' own FDBP-OSD Monte Carlo upper-bound procedure. These are not peripheral issues: they concern the central assertion of the paper. If the authors can later supply rigorous lower bounds for the logical Y and Z distances, together with full simulation details, the work might be reconsidered. As it stands, the central claim is not supported by the derivation."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Two things to know. The XYZ cyclic construction is genuinely new and the repetition-structure conditions are cleanly proven. But the paper's central claim—that this is the only quantum cyclic code family with distance growing in code length—is not supported by the proofs. Proposition 5 is an upper bound on logical-Y weight, Proposition 4 gives an exact X-distance only for a special parameter sequence, and logical-Z is left open in the conclusion. Table I and Fig. 1 come from Algorithm 1, which is explicitly a Monte Carlo upper-bound method using a heuristic decoder, so dZ and dY there are not certified. If a smaller Y- or Z-logical exists, the distance does not grow as claimed and the overhead comparison in Fig. 2 loses its basis.\n\nWhat is good. The code construction with XZYYZX stabilizers appears new relative to the XZZX cyclic codes it cites. Propositions 1-3—Abelianness, dimension, and repetition structure under pure Pauli noise—are self-contained and check out. The 50% pure-Pauli thresholds follow directly from the repetition structure; that part is solid. The 13% depolarizing and 49% biased-noise thresholds are simulation outputs, honestly labeled as such. The authors even list the missing lower-bound proofs as open questions in Sect. V. That restraint is a mark in their favor; the flaw is overclaiming from upper bounds, not fabrication.\n\nSoft spots. The 'only one family' assertion is unsubstantiated; it is a to-our-best-knowledge claim with no survey of cyclic codes. The data are available only on request, so the numerical results are not independently reproducible. And the central distance-growth claim rests on exactly the proofs the paper says it lacks.\n\nWho this is for. A QEC theorist working on biased noise or cyclic stabilizer codes will find the construction and repetition-structure analysis useful. The paper deserves a serious referee: the partial results are clean and the construction is a real building block. But in current form the headline claim should be rejected. The authors should either prove lower bounds for Y and Z or explicitly reframe the paper as a construction with numerical evidence for a distance-growth conjecture.","headline":"New cyclic code family with clean partial proofs, but the headline distance-growth claim rests on unproved lower bounds and Monte Carlo upper bounds—the paper's own open questions confirm this.","tokens_in":21097,"tokens_out":1887,"would_cite":false,"duration_ms":16464,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["81P70","94B15"],"pacs":["03.67.Pp"],"model":"deepseek-v4-flash","headline":"This paper proposes quantum XYZ cyclic codes whose code distance grows with code length, giving 50% pure-Pauli thresholds, about 49% under Z-biased noise, and lower physical overhead than XZZX surface codes at matched distance.","keywords":["quantum XYZ cyclic codes","biased noise","quantum error correction","code distance","repetition code structure","XZZX surface code","FDBP-OSD decoding","code-capacity threshold"],"falsifier":"For a small code in Table I, such as $C(13,2)$ of length $37$ with claimed distance $7$, exhaustively enumerate all logical operators of weight below $7$, or solve the minimum-distance problem by integer programming; finding any logical operator of weight $6$ or less would show the true distance is smaller, and repeating this at several increasing $a$ values with fixed $b$ would directly test whether the true distance actually grows.","tokens_in":20136,"feed_emoji":"⚛️","tokens_out":13049,"duration_ms":96652,"temperature":0.7,"pith_summary":"This paper proposes a family of stabilizer codes it calls quantum XYZ cyclic codes, generated by cyclic shifts of one weight-six Pauli string, and argues that these are the only quantum cyclic codes known whose code distance grows with code length. If that is right, the family matters for biased-noise hardware: under pure Pauli X, Y, or Z noise the codes behave like repetition codes and show 50% code-capacity thresholds, under Z-biased noise with bias ratio $\\eta_Z=1000$ they show about 49%, and under depolarizing noise about 13%. The paper also claims that at matched code distance these codes need fewer physical qubits than XZZX surface codes. A sympathetic reader would care because the construction is a concrete route to reducing qubit overhead in architectures where Z errors dominate.","feed_headline":"Quantum XYZ cyclic codes scale distance with code length","feed_subtitle":"Repetition-style structure gives 50% pure-Pauli thresholds and lower overhead than XZZX surface codes.","key_machinery":"The central object is the quantum XYZ cyclic code $C(a,b)$, whose stabilizer generators are all cyclic shifts of the weight-six string $X Z Y Y Z X$, with $b$ identities between $X$ and $Z$, $a$ identities between $Z$ and $Y$, and one identity between the two $Y$'s. The argument runs through circulant matrices over the binary field and their polynomial representatives: $H_x = 1+x^{a+b+2}+x^{a+b+4}+x^{2(a+b)+6}$, $H_z = x^{b+1}+x^{a+b+2}+x^{a+b+4}+x^{2a+b+5}$, and $H_y = H_x + H_z$. Each polynomial factors into pairs such as $(1+x^{a+b+2})(1+x^{a+b+4})$; when the shifted exponents are coprime to $x^N+1$, the rank drops by one and the code behaves as a repetition code under that Pauli type. Lemma 1 then shows that selecting stabilizer generators at regular intervals produces structured products, which is what allows the exact minimum weight for logical X and the upper bounds for logical Y.","core_discovery":"The central claim is that for suitable natural numbers $a$ and $b$, the quantum XYZ cyclic code $C(a,b)$ of length $N=2(a+b)+7$ encodes one logical qubit and has code distance that increases with $N$. The paper proves three supporting pieces: under coprimality conditions on $a$, $b$, and $N$, the code has repetition-code structure under each of the three pure Pauli noises; for the parameter choice $a=2l(b+2)+l-1$, the minimum weight of the logical X operator is exactly $2l+1$, which grows linearly with $N$; and the logical Y operator weight is bounded above by $2b+5$, or $2b+3$ when $b=3l-1$. For the logical Z operator, an exact proof is left open and the paper instead reports Monte Carlo estimates that also grow with $a$. Putting these together, the paper concludes that increasing $b$ increases the code distance, giving thresholds of 50% for pure Pauli noise, about 49% for Z-biased noise at $\\eta_Z=1000$, and about 13% for depolarizing noise, with lower physical-qubit overhead than XZZX surface codes at matched distance.","pith_inferences":["Beyond the paper: the distance-growth claim would become fully rigorous only if the open Z-logical lower bound and a matching Y lower bound were proved; until then the family is numerically, not provably, distance-growing.","Beyond the paper: the overhead comparison at matched code distance does not by itself guarantee a lower logical error rate at fixed physical overhead; circuit-level simulations with noisy syndrome extraction would test the practical gain.","Beyond the paper: the same circulant-polynomial machinery could be applied to other weight-six generator strings to screen for cyclic codes with repetition structure under biased noise."],"forward_implications":["The family would be the first quantum cyclic code family whose code distance grows with code length, a property previously open even for XZZX cyclic codes.","Under pure Pauli noise the repetition-code structure makes the logical error probability decay with code length, consistent with the simulated 50% thresholds.","At matched code distance, the reported physical-qubit overhead is much lower than that of XZZX surface codes, so the codes could reduce hardware requirements in biased-noise architectures.","The parameter table gives concrete \"optimal\" codes for $b=0$ through $11$ with distances from $5$ to $27$, providing a starting point for implementation or further study.","Supplying the missing lower bound for the Z logical operator would turn the numerical distance-growth evidence into a theorem."],"supporting_citations":[{"why":"It documents architectures where Pauli Z errors dominate by a factor near $10^3$, setting the bias regime the codes target.","marker":"[3]"},{"why":"It supplies the XZZX surface-code baseline used for the threshold and physical-qubit-overhead comparison.","marker":"[8]"},{"why":"It supplies the Monte Carlo method used to compute upper bounds on code distance.","marker":"[9]"},{"why":"It supplies the FDBP-OSD decoder used inside the Monte Carlo distance-bound algorithm and in the performance simulations.","marker":"[11]"},{"why":"It introduces the XZZX cyclic code family whose open distance-growth question motivates the XYZ cyclic construction.","marker":"[14]"},{"why":"It establishes hardness of exact minimum-distance computation, motivating the Monte Carlo upper-bound approach.","marker":"[16]"},{"why":"It provides the rank and gcd formula used to compute the code dimension of the XYZ cyclic codes.","marker":"[20]"}],"fun_headline_variants":["XYZ cyclic codes: distance grows with length, 50% pure-Pauli thresholds","Quantum XYZ cyclic codes beat XZZX overhead at matched distance","Biased-noise tailored cyclic codes hit 50% pure-Pauli threshold","New cyclic codes scale distance, cut qubit overhead vs XZZX surface"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The distance-growth conclusion rests on the assumption that the values reported as $d_X$, $d_Y$, and $d_Z$ are the true minimum logical-operator weights; the paper proves an exact minimum only for the $X$ operator in a special parameter sequence, gives only an upper bound for $Y$, and estimates $Z$ with a decoder that is not guaranteed to find the true minimum.","fun_headline_variants_meta":{"raw":{"variants":["XYZ cyclic codes: distance grows with length, 50% pure-Pauli thresholds","Quantum XYZ cyclic codes beat XZZX overhead at matched distance","Biased-noise tailored cyclic codes hit 50% pure-Pauli threshold","New cyclic codes scale distance, cut qubit overhead vs XZZX surface"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000241,"raw_usage":{"total_tokens":1536,"prompt_tokens":974,"completion_tokens":562,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":590,"completion_tokens_details":{"reasoning_tokens":480}},"tokens_in":590,"tokens_out":562,"duration_ms":4937,"temperature":1.0,"reasoning_tokens":480,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-10T10:21:27.031764+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"For a small code in Table I, such as $C(13,2)$ of length $37$ with claimed distance $7$, exhaustively enumerate all logical operators of weight below $7$, or solve the minimum-distance problem by integer programming; finding any logical operator of weight $6$ or less would show the true distance is smaller, and repeating this at several increasing $a$ values with fixed $b$ would directly test whether the true distance actually grows.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"It documents architectures where Pauli Z errors dominate by a factor near $10^3$, setting the bias regime the codes target."},{"cited_title":"Aliferis, F","cited_arxiv_id":null,"evidence_quote":"It supplies the Monte Carlo method used to compute upper bounds on code distance."},{"cited_title":"Chamberland, K","cited_arxiv_id":null,"evidence_quote":"It supplies the FDBP-OSD decoder used inside the Monte Carlo distance-bound algorithm and in the performance simulations."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"It introduces the XZZX cyclic code family whose open distance-growth question motivates the XYZ cyclic construction."},{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"It provides the rank and gcd formula used to compute the code dimension of the XYZ cyclic codes."}],"review_version":1}