{"id":"c5f97250-4312-4ae3-a150-74d8e06232e5","arxiv_id":"2505.07130","paper_version":2,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":2,"one_line_summary":"Every projective linear code can be converted, via a simplex complementary code and a length extension, into a minimal linear code violating the Ashikhmin-Barg condition.","lead":"This paper gives a general recipe that turns any minimal linear code satisfying the Ashikhmin-Barg condition into a minimal code that violates it, and then runs every projective linear code through that recipe. It produces many new minimal codes with fully computed weight distributions, several of which match or approach the best known parameters.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"Theorem 2.1 is false for k=1: the construction needs two generator rows, and the one-dimensional [1,1,1]_q code yields C' with w_min/w_max=1, not an AB violation.","rationale":"The reader's weakest assumption concerns Theorem 3.1's complementary-code parameters being imported from [9]. I checked those parameters independently: for a linear functional L on F_q^{k+h}, the punctured simplex codeword has weight q^{k+h-1} minus the number of deleted columns on which L is nonzero, and the maximum of that count is exactly the maximum weight w of C; a functional vanishing on F_q^k x {0} gives the maximum weight q^{k+h-1}. So Theorem 3.1 is essentially correct despite the compressed proof. The actual load-bearing flaw I find is in Theorem 2.1, which is one of the two central pillars and is stated without any k>=2 hypothesis. The k=1 counterexample is definitive and reproducible, and it invalidates the claim as written. The intended pipeline for arbitrary projective codes still works because the intermediate code from Theorem 3.1 has dimension at least 2, so the paper can be repaired by restricting Theorem 2.1 to k>=2 and noting that one-dimensional AB-satisfying codes are an exception. This does not change the overall conditional verdict, but it should be fixed before the paper is accepted.","tokens_in":22963,"tokens_out":22477,"duration_ms":221620,"concrete_test":"Instantiate the construction of Theorem 2.1 with q=2 and C=[1,1,1]_2. Compute n'=ceil(2/1)-1=1, so G'=[1 1] and C'={00,11}. The ratio w_min/w_max equals 1, while (q-1)/q=1/2, so the output code does not violate the Ashikhmin-Barg condition. This single reproducible check settles the concern. After adding the hypothesis k>=2, one should also re-run the proof of Theorem 2.1 on a k=2 example such as C=[3,2,2]_2 to confirm the minimality argument still works in the intended regime.","verdict_should_be":"UNCHANGED","load_bearing_attack":"Theorem 2.1 is stated for every q-ary k-dimensional linear code C satisfying the Ashikhmin-Barg condition, but its proof requires a second generator row r_2 of minimum weight. For k=1 this row does not exist, and the claim is actually false. Let C=[1,1,1]_q be the one-dimensional projective code with generator matrix [1]. It is minimal and satisfies w_min/w_max=1>(q-1)/q. The construction gives n'=ceil(q/(q-1))-1=1 and G'=[1 1], so C' is the one-dimensional repetition code {00,11} (over F_2; analogous over any q). Its minimum and maximum weights are both 2, so w_min(C')/w_max(C')=1, which does not violate the Ashikhmin-Barg condition. The theorem's assertion w_min(C')=w_min also fails: the subcode C^* is the zero code, so no codeword of weight w_min survives. This is not a missing edge-case discussion; it is a direct counterexample to the universal statement in Theorem 2.1 and to the abstract's 'general method' phrasing. The arbitrary-projective-code pipeline is not destroyed, because the simplex complementary code of Theorem 3.1 has dimension k+h>=2, but Theorem 2.1 as written needs an explicit k>=2 hypothesis or a separate treatment of the one-dimensional case.","agreement_with_reader":"disagree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper develops a method to convert minimal q-ary linear codes satisfying the Ashikhmin-Barg condition wmin/wmax > (q-1)/q into minimal codes violating it. The transformation takes a generator matrix whose first row is a maximum-weight codeword, prepends a constant nonzero block of length n' = ceil(q wmin/(q-1)) - wmax to that row, and zero-pads the other rows; Theorem 2.1 claims the resulting code is minimal, has minimum weight wmin and maximum weight at least wmax + n', so that wmin/wmax(C') <= (q-1)/q. The paper then recalls, from the authors' earlier work [9], the simplex complementary code of a projective [n,k]_q code, which has parameters [(q^{k+h}-1)/(q-1)-n, k+h, q^{k+h-1}-w]_q and maximum weight q^{k+h-1}, and is AB-satisfying when h > log_q w - k + 2. Combining the two results, the paper claims that every projective linear code can be transformed into a minimal AB-violating code. It gives several infinite families, including binary self-orthogonal examples, and determines weight distributions of the transformed codes.","tokens_in":23158,"tokens_out":25367,"duration_ms":240496,"significance":"The transformation is an attractive, explicit tool: it produces AB-violating minimal codes from any AB-satisfying code with one extra parameter, and the weight-distribution formula in Theorem 6.1 is precise and easy to apply; some examples are checked by Magma. If the claims stand, the paper provides a very broad class of AB-violating minimal codes and many near-optimal parameters. The main obstacle is that Theorem 2.1 is false for k=1, and the proof of the central minimality claim, as well as the self-orthogonal variant, need to be completed. These are repairable, so the overall program is defensible but not yet fully established.","major_comments":[{"comment":"Theorem 2.1 is false as stated for k = 1, since the construction requires a second generator row of minimum weight. Taking C = [1,1,1]_q, we have wmin = wmax = 1 and AB is satisfied; the construction gives n' = 1 and C' = {00, 11} (up to scalar normalization), whose minimum and maximum weights are both 2, so wmin(C')/wmax(C') = 1 > (q-1)/q and wmin(C') is not equal to wmin. The theorem needs an explicit hypothesis k >= 2 (or a separate treatment of k = 1), and the proof should justify that for k >= 2 a minimum-weight row r2 can be chosen linearly independent of the maximum-weight row r1.","section":"Theorem 2.1 (Section 2)"},{"comment":"The minimality argument in Case 2 is incomplete. From supp(x'_2) subset of supp(x'_1) and minimality of C one obtains x'_2 = lambda' x'_1, but this alone does not imply that x2 cannot lie in the subspace spanned by r'_2,...,r'_k; one must use that the projection y1 of x1 has a nonzero r1-component and hence is not in C* = span(r2,...,rk), so lambda' y1 cannot occur as the last block of a codeword with zero first block. Without this rank/span argument the assertion 'Therefore, x2 cannot be...' does not follow. The proof also states wmin(C') = wmin without proving the lower bound; this bound should be stated explicitly, since any codeword either has weight at least wmin from C*, or weight at least n' + wmin from the first block.","section":"Section 2, proof of Theorem 2.1, Case 2"},{"comment":"The self-orthogonal version is not proved. The proof of Corollary 2.1 is a single sentence, and no condition on the prepended block a is derived. For binary codes, (a,r1)·(a,r1) = wt(a) + wt(r1) mod 2; if C is doubly even, wt(r1) = 0 mod 4, so one needs wt(a) even. When a is the all-one vector of length n', this requires n' even, whereas the corollary states length n+n'+1, suggesting an extra coordinate is used; Section 5's examples use length n+n' with no extra coordinate. The statement needs an explicit construction and a proof that the chosen a (and extra coordinate, if any) preserves self-orthogonality, since all the infinite self-orthogonal families in Section 5 depend on this result.","section":"Corollary 2.1 and Section 5"}],"minor_comments":[{"comment":"The text contains typos such as 'Ashikhamin-Barg', 'codndition', and 'simplx'; these should be corrected throughout.","section":"Abstract and headings"},{"comment":"The proof writes h >= log_q w - k + 2, but the strict inequality h > log_q w - k + 2 is required for the strict Ashikhmin-Barg comparison; the proof should be aligned with the theorem statement.","section":"Theorem 3.1, proof"},{"comment":"The complementary-code parameters are imported from [9] without a specific statement or theorem number; please cite the exact result in [9] so the reader can verify that the hypotheses (projectivity, the length condition, and the embedding dimension) match the present setting.","section":"Theorem 3.1 and reference [9]"},{"comment":"The theorem describes the 'set of nonzero weights' as a union; if a weight w_i occurs only in C* or only outside C*, one of the two corresponding multiplicities is zero, so the displayed union is the set of possible weights rather than necessarily the exact support. This should be stated more precisely.","section":"Theorem 6.1"},{"comment":"The row '[292, 8, 96]_2 -> [256, 8, 96]_2' is suspicious because Theorem 2.1 should increase the length; please check the parameters and the underlying computation for that row.","section":"Table 2"},{"comment":"The assertion that the simplex complementary code of a doubly even binary code is again doubly even is used without proof or reference; it is true but should be justified.","section":"Section 5"},{"comment":"Some examples refer to 'optimal' minimum distances when the cited tables give the best known lower bound; the terminology should be made consistent.","section":"Terminology"}],"recommendation":"major_revision","confidential_remarks":"To the editor: the k=1 counterexample is a clear, fixable flaw in the main transformation, and the other proof gaps are local rather than fatal. The paper leans heavily on the authors' published work [9] for Theorem 3.1, so a referee should confirm that [9]'s complementary-code theorem is indeed published and that its hypotheses cover the use made here. Section 4.2 also cites the companion manuscript [10] as 'submitted'; the editors should ask the authors to clarify the status of [10] and to make the dependence on it explicit. I do not see grounds for rejection, but the manuscript should not be accepted until Theorem 2.1 is corrected and the minimality and self-orthogonality proofs are completed."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"Punchline: this is a genuinely useful toolkit, but Theorem 2.1 as stated is false for k=1. The fix is trivial (add k>=2), and the rest of the paper's central idea survives.\n\nThe new content is real. The padding construction that forces w_min/(w_max+n') <= (q-1)/q is a general transformation with no counterpart in the old function-by-function constructions, and the weight-distribution formula in Theorem 6.1 is clean and, as far as I can tell, correct. The simplex-complement route from arbitrary projective codes is also new and makes the result an organizing statement for the subfield, not just another family. The self-orthogonal section is a useful bonus.\n\nThe soft spots, in order of severity. First, the counterexample: for C=[1,1,1]_q, k=1, n'=1, and G' gives the two-bit repetition code with w_min/w_max=1, so neither the inequality nor the claimed w_min(C')=w_min holds. The proof explicitly needs a second generator row, so the theorem needs a k>=2 hypothesis or a separate one-dimensional case. This does not destroy the arbitrary-projective-code pipeline, because the simplex complement has dimension k+h>=2, but the abstract's 'general method' phrasing is too strong. Second, Corollary 2.1's self-orthogonality claim is one sentence and never checks the parity condition; likely true but unproven. Third, Theorem 3.1 leans entirely on the complementary-code parameters from the authors' published [9], and several families depend on the unpublished [10]. The reader's concern here is fair: if [9] has a hole, the pipeline has a hole. Fourth, Table 2 has arithmetic errors ([292,8,96]_2 cannot come from the stated Solomon-Stiffler formulas; [153,7,54]_2 is inconsistent with n'=44), and the codetable comparisons are taken at face value. These are presentation-level problems but they undercut the near-optimality claims.\n\nBottom line: the central construction is sound for k>=2, the machinery is genuinely useful, and the flaws are fixable. This deserves refereeing, not desk rejection. A serious referee should insist on a corrected theorem statement, a real proof of the self-orthogonal parity condition, and a cleaned-up Table 2.","headline":"A genuinely useful toolkit for building AB-violating minimal codes, but Theorem 2.1 is false as stated for k=1; fix that edge case and the table errors and this deserves refereeing.","tokens_in":23789,"tokens_out":2629,"would_cite":true,"duration_ms":25012,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["94B05","94B65"],"pacs":[],"model":"deepseek-v4-flash","headline":"This paper proves that every projective linear code can be converted, through a simplex complementary construction followed by a generator-block padding step, into a minimal code violating the Ashikhmin-Barg condition while preserving its…","keywords":["minimal linear codes","Ashikhmin-Barg condition","projective linear codes","simplex complementary codes","weight distribution","self-orthogonal codes","optimal linear codes"],"falsifier":"Take a small projective code such as the binary $[4,3,2]_2$ code, delete its four columns from the binary simplex $[2^{k+h}-1,\\ k+h,\\ 2^{k+h-1}]_2$ generator matrix for $h=1$ and $h=2$, and compute the true minimum distance and maximum weight by exhaustive search; if either differs from $q^{k+h-1}-w$ or $q^{k+h-1}$, Theorem 3.1's parameter claim is false and the arbitrary-projective-code conversion fails at that step.","tokens_in":22652,"feed_emoji":"🔢","tokens_out":8160,"duration_ms":73940,"temperature":0.7,"pith_summary":"Minimal linear codes are codes in which no nonzero codeword's support contains another's except by scalar multiplication, and the Ashikhmin-Barg condition $w_{\\min}/w_{\\max} > (q-1)/q$ is a well-known sufficient test for minimality that is not necessary. The paper proves a general transformation: given any $q$-ary linear code satisfying that condition, append a block of $n' = \\lceil q w_{\\min}/(q-1)\\rceil - w_{\\max}$ nonzero coordinates to a maximum-weight generator row and pad all other rows with zeros; the new code is still minimal, keeps minimum weight $w_{\\min}$, and has weight ratio at most $(q-1)/q$, so it violates the condition. It then shows that the simplex complementary code of any projective linear code satisfies the condition once enough extra coordinate dimensions are added. Together these two steps turn arbitrary projective linear codes into minimal codes that violate the Ashikhmin-Barg condition, replacing a collection of special constructions with a general pipeline.","feed_headline":"Padding turns minimal codes into Ashikhmin-Barg violators","feed_subtitle":"From any projective code the construction keeps its minimum distance while pushing the weight ratio to (q−1)/q or below.","key_machinery":"The load-bearing object is the padded generator matrix $G'$ with first row $(a, r_1)$, where $a$ is a block of $n' = \\lceil q w_{\\min}/(q-1)\\rceil - w_{\\max}$ nonzero coordinates and $r_1$ is a maximum-weight codeword of $C$, while every other row has zeros in the first $n'$ positions. A codeword using the first row has full weight in the padding block and a codeword of $C$ in the remaining coordinates, so its weight is at least $w_{\\min} + n'$; a codeword avoiding the first row is just a codeword of the old code. Support containment then forces the two codewords to be scalar multiples, preserving minimality, while the ratio $w_{\\min}/(w_{\\max}+n')$ drops to $(q-1)/q$ or below. The complementary ingredient is the simplex complementary code of a projective code: delete the columns of the projective code from a simplex generator matrix and lift the dimension by appending zero coordinates, yielding a code whose asserted minimum distance is $q^{k+h-1}-w$ and maximum weight $q^{k+h-1}$.","core_discovery":"Theorem 2.1 states that from any $q$-ary linear code $C$ with $w_{\\min}/w_{\\\\max} > (q-1)/q$, the explicit generator matrix whose first row is $(a, r_1)$, where $a$ is a block of $n' = \\lceil q w_{\\min}/(q-1)\\rceil - w_{\\max}$ nonzero field elements and $r_1$ is a maximum-weight codeword, and whose remaining rows are $(0, r_i)$, produces a minimal code $C'$ with minimum weight $w_{\\min}$ and $w_{\\min}(C')/w_{\\max}(C') \\le (q-1)/q$. Theorem 3.1 adds that the simplex complementary code of a projective $[n,k]_q$ code with maximum weight $w$ has parameters $[(q^{k+h}-1)/(q-1)-n,\\ k+h,\\ q^{k+h-1}-w]_q$, maximum weight $q^{k+h-1}$, and satisfies the Ashikhmin-Barg condition when $h > \\log_q w - k + 2$. Consequently, every projective linear code can be transformed, in two steps, into a minimal linear code violating the Ashikhmin-Barg condition.","pith_inferences":["If the imported simplex-complementary parameter formula is sound, the two-step pipeline suggests that Ashikhmin-Barg-violating minimal codes are a generic phenomenon, not a rare special construction; one should expect them across most parameter ranges.","The construction saturates the boundary by achieving weight ratio at most $(q-1)/q$, which raises the natural dual question of how much padding is necessary to reach a given ratio and whether every minimal AB-violating code can be traced back to an AB-satisfying ancestor.","The self-orthogonal variant points toward possible applications in secret-sharing and secure computation, where minimal codes with small weight ratios are used to shape access structures, though connecting these specific parameters to access-structure properties would require further analysis."],"forward_implications":["Any $q$-ary linear code meeting the Ashikhmin-Barg condition can be run through the padding transform, so minimal codes violating the condition no longer depend on special Boolean functions, partial difference sets, or few-weight constructions.","The padding step preserves the minimum weight exactly, so codes whose minimum distance is already near optimal or best known can be converted into Ashikhmin-Barg-violating codes with only a modest increase in length.","Because Theorem 3.1 produces an Ashikhmin-Barg-satisfying minimal code from any projective linear code, every projective code, including multi-weight and non-minimal codes, feeds the construction; the paper demonstrates this on best-known table codes.","When the input code is self-orthogonal, such as a doubly even binary code, the output can be made self-orthogonal as well, yielding infinite families of binary self-orthogonal minimal codes violating the condition.","The weight distribution of the output is completely determined from the input weight distribution and the distribution of the subcode generated by all but the first generator row, so the spectra of the new minimal codes are explicit."],"supporting_citations":[{"why":"Defines minimal codewords and gives the Ashikhmin-Barg ratio condition that Theorem 2.1 takes as its starting hypothesis.","marker":"[3]"},{"why":"Supplies the simplex complementary code construction and the parameter formula on which Theorem 3.1's distance and maximum-weight claims rest.","marker":"[9]"},{"why":"Provides the optimal and best-known minimum distances used to support the paper's claims that many constructed codes are optimal, almost optimal, or close to best known.","marker":"[16]"}],"fun_headline_variants":["Any projective code yields a minimal Ashikhmin-Barg violator","Padding trick turns any projective code into an AB-rule breaker","Every projective code can be padded into a minimal AB violator","Minimal AB-violating codes from any projective code","Construction turns arbitrary projective codes into AB violators"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The entire construction leans on the imported parameter formula for the simplex complementary code—that its minimum distance is exactly $q^{k+h-1}-w$ and its maximum weight exactly $q^{k+h-1}$—so if that formula fails for some projective input code, the claimed conversion collapses, and the present paper does not independently prove the formula.","fun_headline_variants_meta":{"raw":{"variants":["Any projective code yields a minimal Ashikhmin-Barg violator","Padding trick turns any projective code into an AB-rule breaker","Every projective code can be padded into a minimal AB violator","Minimal AB-violating codes from any projective code","Construction turns arbitrary projective codes into AB violators"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000941,"raw_usage":{"total_tokens":4054,"prompt_tokens":1010,"completion_tokens":3044,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":626,"completion_tokens_details":{"reasoning_tokens":2962}},"tokens_in":626,"tokens_out":3044,"duration_ms":23984,"temperature":1.0,"reasoning_tokens":2962,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-15T22:27:35.290354+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take a small projective code such as the binary $[4,3,2]_2$ code, delete its four columns from the binary simplex $[2^{k+h}-1,\\ k+h,\\ 2^{k+h-1}]_2$ generator matrix for $h=1$ and $h=2$, and compute the true minimum distance and maximum weight by exhaustive search; if either differs from $q^{k+h-1}-w$ or $q^{k+h-1}$, Theorem 3.1's parameter claim is false and the arbitrary-projective-code conversion fails at that step.","supporting_citations":[{"cited_title":"Ashikhmin and A","cited_arxiv_id":null,"evidence_quote":"Defines minimal codewords and gives the Ashikhmin-Barg ratio condition that Theorem 2.1 takes as its starting hypothesis."},{"cited_title":"Chen and C","cited_arxiv_id":null,"evidence_quote":"Supplies the simplex complementary code construction and the parameter formula on which Theorem 3.1's distance and maximum-weight claims rest."},{"cited_title":"Grassl, Bounds on the minimum distance of linear codes and qua ntum codes, Online available at http://www.codetables.de","cited_arxiv_id":null,"evidence_quote":"Provides the optimal and best-known minimum distances used to support the paper's claims that many constructed codes are optimal, almost optimal, or close to best known."}],"review_version":1}