{"id":"f3ac82a6-473c-4068-bcda-5a2f0afc279d","arxiv_id":"2607.22828","paper_version":1,"verdict":"ACCEPT","confidence":"HIGH","novelty_score":8.0,"correctness_risk":"low","formal_verification":"none","parameter_count":3,"one_line_summary":"There exist IRT-free subsets of the n×n grid of size n^{1.318-o(1)}.","lead":"The paper constructs subsets of the n-by-n integer grid with no isosceles right triangle that are much larger than previously known, of size about n^1.318. It adapts the classic Salem–Spencer digit trick to two dimensions by using Gaussian integers and a novel 'peeling' order, verified with a computational certificate.","discovery_kind":"new_method","skeptic_critique":{"model":"deepseek-v4-flash","headline":"No significant objection identified","rationale":"The reader identified the finite certificate as the weakest assumption, and I concur that this is the only place where the argument depends on a computational check rather than a human-readable proof. However, after examining the verifier, I find it to be a correct and complete check of both the IRT-carry-free condition and the IRT-peeling order. The carry-free check's O(q^2) optimization is justified by the fact that P is a partial system of residues: for fixed b,c there is at most one a with the correct residue. The peeling loop checks the exact definition. The proof of Theorem 2.6 is mathematically solid, with the peeling induction correctly using equal composition vectors. The geometric Lemma 3.3 independently establishes carry-freeness for the whole region C, so even if the verifier's carry check were flawed, the mathematical result would still follow from the order check alone. Thus no load-bearing concern survives. The abstract's Omega(n^1.3) follows from the slightly stronger theorem with alpha > 1.3. The theorem statement's 'for every n>1' is a minor Vinogradov-notation issue but fixable with a small constant. I recommend no change to the ACCEPT verdict.","tokens_in":9376,"tokens_out":20869,"duration_ms":171479,"concrete_test":"Run an independent brute-force checker on the 281-point list: for every triple (a,b,c) in P^3, verify a+ic=(1+i)b follows from a+ic-(1+i)b in beta Z[i] (carry-free), and for every t and every a,c in the suffix R_t, verify a+ic=(1+i)p_t implies a=c=p_t (peeling). Compare both to the provided Python verifier's pass. This would settle whether any optimized-check bug exists in Appendix B.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The only potentially load-bearing step is the finite certificate: the 281-point ordered list must satisfy the IRT-peeling condition for Theorem 4.2, and the proof delegates this to the Python verifier in Appendix B. I reviewed the verifier and the surrounding proof with care. The peeling check directly tests the required suffix property: for each t and each c in the suffix, it computes the forced a and rejects nondegenerate solutions. The carry-free check is complete despite being O(q^2) rather than O(q^3), because P is a partial residue system: for each (b,c) there is at most one a in P with the relevant residue modulo beta, so checking that a is sufficient. The geometric Lemma 3.3 independently proves the carry-free property for the entire region C, making the verifier's carry check redundant. The induction in Theorem 2.6 is sound: the peeling order propagates through digit positions because equal composition vectors give equal digit counts. I found no internal inconsistency and no unsupported mathematical assumption; the reliance on a short, transparent verifier is acceptable in a computer-assisted proof of this type.","agreement_with_reader":"agree"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper gives a lower bound for F(n), the maximum size of a subset of the n×n grid containing no nondegenerate isosceles right triangle. The construction works over the Gaussian integers, where an IRT with right angle at b is encoded by a + ic = (1+i)b. A digit alphabet P is called IRT-carry-free if this equation has no carry modulo β, and is equipped with an IRT-peeling order if points can be removed one by one so that each removed point is not the right-angle vertex of any IRT in the remaining suffix. Theorem 2.6 shows that from such an alphabet of size q in base β one obtains F(n) ≫ n^{log q / log|β|} / (log n)^{(q-1)/2}. A small example gives exponent about 1.0566. Section 3 proves a geometric lemma supplying carry-free diamond regions for bases β=(2k+1)(1+i). The main construction uses β=51+51i and a 281-point alphabet found by an AlphaEvolve-assisted search; the peeling and carry-free properties of the list are verified by a standalone Python program in Appendix B. This yields Theorem 4.2: F(n) ≫ n^α/(log n)^{140} with α = log 281 / log|51+51i| ≈ 1.317865485534, so F(n) ≥ n^{α-o(1)}.","tokens_in":9650,"tokens_out":23449,"duration_ms":222304,"significance":"If the finite certificate is accepted, this is the first superlinear lower bound for F(n), improving the trivial linear lower bound and complementing the upper bound F(n) ≪ n^2/(log n)^{1+c}. The main mathematical novelty is the peeling order, which allows the digit alphabet itself to contain forbidden triangles, and the use of composition classes so that peeling propagates through every digit position. The separation of a clean geometric carry-free argument from a finite computer-verified search is methodologically sound. A reproducible Python verifier and a SHA-256 digest are included, which is a real strength: the mathematical derivation does not depend on the search algorithm once the certificate is accepted.","major_comments":[],"minor_comments":[{"comment":"The size estimate |W_m| ≫ q^m / m^{(q-1)/2} is introduced immediately after an averaging argument over all compositions, but the average gives only q^m / m^{q-1}. The better bound follows by choosing a composition with nearly equal coordinates and applying Stirling's formula to that multinomial coefficient. Please make this choice explicit so the logical step is unambiguous.","section":"§2, proof of Theorem 2.6"},{"comment":"The text refers to Theorem 2.4, but the referenced result is Theorem 2.6. Please correct the cross-reference.","section":"§3, first sentence"},{"comment":"The sentence 'Theorem 2.6 applied to this construction yields or main result' contains a typo: 'or' should be 'our'.","section":"§4, before Theorem 4.2"},{"comment":"The statement says 'For every integer n>1', but the proof establishes the bound only for sufficiently large n, with the usual Vinogradov convention. Either state 'for all sufficiently large n' or explain how the finitely many small n are absorbed by adjusting the implied constant.","section":"Theorem 4.2"},{"comment":"In the version of the manuscript I received, the verbatim Python listing appears to have lost whitespace in import statements and after keywords such as 'return', which would make the code syntactically invalid as printed. If this is not a rendering artefact, please ensure the published source contains valid Python. Also confirm that the machine-readable \\PointData macro is actually embedded in the TeX source, since the verifier reads directly from it.","section":"Appendix B, verifier"},{"comment":"The assertion that the displayed function attains its maximum for positive integers at k=5 is stated without proof or numerical evidence. A one-line verification or a reference to a short computation would be helpful.","section":"Remark 3.2"}],"recommendation":"minor_revision","confidential_remarks":"The mathematical core of the paper appears sound. I carefully checked the peeling induction in Theorem 2.6 and the geometric carry-free Lemma 3.3; the only non-human-checkable ingredient is the 281-point certificate. I reviewed the verifier's logic: the peeling check directly tests the required suffix property, and the carry check is complete because P is a partial residue system. The composition-class size estimate needs a small clarification, and there are a few local typos. I support publication after minor revisions."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The big news: this paper finally breaks the linear barrier for F(n), giving F(n) = n^{1.3179 - o(1)}. That alone would make it worth reading, but the construction is also more than a routine digit trick. The Salem–Spencer idea is adapted to Gaussian integers, with a carry-free diamond region that makes the digitwise argument work, and the genuinely new twist is the peeling order: digits can contain isosceles right triangles as long as they can be eliminated one by one. That feels like the right conceptual step, and it is likely to be reused for other forbidden configurations.\n\nThe proof itself is in good shape. The geometric Lemma 3.3 cleanly establishes the carry-free condition for the diamond region. The induction in Theorem 2.6 propagates the peeling order through digit positions via composition classes, and the counting argument is standard. The finite 281-point certificate is checked by a short Python verifier included in the appendix, with a SHA-256 digest to prevent transcription errors. I ran through the verifier logic mentally and the peeling check directly tests the required suffix property; the carry check is in fact redundant given Lemma 3.3, but harmless. The reliance on an external program is the weakest link, but for a finite certificate of this size it is acceptable—the code is simple enough that a skeptical reader can verify it by hand or with a different implementation.\n\nSoft spots worth noting, none fatal. The verifier itself is not formally proved, so someone could object that a bug in the code could sink the theorem; in practice this is a minor concern. The exponent 140 in the log factor is ugly and almost certainly improvable; the authors do not claim otherwise. The gap between this lower bound and the n^2/(log n)^{1+c} upper bound remains enormous, but that is a statement about the problem's difficulty, not a flaw in the paper. I also appreciate that Remark 4.3 explicitly disclaims that the search proves optimality of the alphabet.\n\nThe reader's ACCEPT verdict and the stress-test note both hold up on reading the actual manuscript. The citation pattern looks fine: the relevant prior work is cited, and the AlphaEvolve tool is presented honestly as a discovery mechanism, with the mathematical certificate independently checked.\n\nWho should read this: anyone working on Roth-type problems in higher dimensions, additive combinatorics with matrix coefficients, or computer-assisted combinatorial constructions. It deserves a serious referee—the result is new, the method is interesting, and the verification is transparent. I would send it to a good combinatorics journal and expect it to survive review with at most minor revisions.","headline":"First superlinear lower bound for IRT-free grid subsets, with a genuinely new peeling technique and a checkable finite certificate.","tokens_in":10058,"tokens_out":1242,"would_cite":true,"duration_ms":14091,"reading_group":"yes","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":["05D10","11B30"],"pacs":[],"model":"deepseek-v4-flash","headline":"The paper proves that every n×n integer grid contains an isosceles-right-triangle-free subset of size at least n^{1.317865}/log(n)^{140}, the first lower bound exceeding linear.","keywords":["isosceles right triangle-free","integer grid","Gaussian integers","peeling order","carry-free digit set","lower bound","Roth-type problem","computer-assisted certificate"],"falsifier":"Run the provided verifier on the 281-point list: if it reports any failed assertion — for example, a digit c in a remaining suffix for which a=(1+i)p_t−ic is also in the suffix with (a,c) not equal to (p_t,p_t), or a nonzero carry δ divisible by β — the construction collapses. A direct search over the encoded set A_m for a nondegenerate solution of a+ic=(1+i)b would also disprove the claim.","tokens_in":9304,"feed_emoji":"📐","tokens_out":4496,"duration_ms":44680,"temperature":0.7,"pith_summary":"The paper establishes a new lower bound for F(n), the largest size of a subset of the n×n integer grid containing no nondegenerate isosceles right triangle: F(n) is at least n^{1.317865}/log(n)^{140}, up to constants. This is the first known superlinear lower bound for this quantity. The construction adapts the classic digit-based method for 3-term arithmetic progressions to two dimensions, working over Gaussian integers and using a finite alphabet of 281 digits. A key novelty is a 'peeling order' on the digits, which allows the alphabet itself to contain forbidden triangles as long as they can be removed one vertex at a time. The result rests on a computer-verified finite certificate.","feed_headline":"New lower bound: grid sets avoid right isosceles triangles at n^1.317","feed_subtitle":"First superlinear lower bound for F(n): a digit-encoding construction over Gaussian integers beats all previous ones.","key_machinery":"The central mechanism is the IRT-peeling order: an ordering p_1,...,p_q of a digit alphabet such that for each t, the only solution to a+ic=(1+i)p_t with a,c in the remaining suffix is a=c=p_t. This is paired with the IRT-carry-free condition, which says that a+ic-(1+i)b is divisible by β only when it equals zero. Together they allow the digitwise proof to go through — the carry-free condition kills any carry at each digit, and the peeling order kills any triangle whose right-angle vertex is the next digit to be peeled. A composition class (words with nearly equal digit counts) supplies the large family of encoded grid points.","core_discovery":"Over the Gaussian integers, an isosceles right triangle with right angle at b is encoded by the linear equation a+ic=(1+i)b. The paper chooses the base β=51+51i and a 281-point digit set inside a carry-free diamond region. It then provides an ordering of these digits — the peeling order — such that for every suffix of the ordering, no nondegenerate triangle has its right-angle vertex at the first digit of that suffix. Encoding words with nearly uniform digit frequencies into Gaussian integers produces a set with no forbidden triangles and size roughly n^{log 281 / log|β|}/(log n)^{140}, giving the stated exponent. The geometric carry-free argument and the combinatorial peeling argument toget","pith_inferences":["The exponent 1.317865 is almost certainly not the end of the story; larger carry-free regions, asymmetric shapes, or block digits could plausibly raise it, while the large gap to the upper bound suggests room for further constructions.","If the peeling technique could be combined with a density increment or Fourier-based upper-bound argument, one might approach exponents closer to 2, though the paper itself does not attempt this.","The credibility of the theorem hinges on the correctness of the verifier and the transcribed 281-point list; a human-readable or formally verified proof of the finite certificate would make the result fully independent of computational trust.","The paper notes that 281 is not proved to be maximal in the diamond region; an exact optimization of the alphabet size in that region could either produce a better exponent or reveal a flaw in the current certificate."],"forward_implications":["If correct, this gives F(n) ≥ n^{1.317865-o(1)}, the first lower bound with exponent greater than 1, shrinking the gap to the known upper bound n^2/(log n)^{1+c}.","The method is general: any Gaussian base β with an IRT-carry-free, peelable alphabet of size q yields F(n) ≫ n^{log q/log|β|}/(log n)^{(q-1)/2}, so improving the digit search in other bases could improve the exponent.","The peeling-order idea applies beyond isosceles right triangles to other rotation-invariant or matrix-coefficient equations, suggesting new digit-encoding constructions in higher dimensions or with other forbidden shapes.","The finite certificate is independently checkable by a standalone program, so the mathematical reduction is separated from the computational discovery and can be verified directly from the paper's source.","Even the smallest nontrivial example — a 3-digit alphabet in base 2+2i — already yields an exponent above 1 (about 1.0566), showing the phenomenon is not unique to the large 281-digit construction."],"fun_headline_variants":["Gaussian digit peeling builds n^1.3 triangle-free grid subsets","First superlinear bound for grid sets without isosceles right triangles","New digit-encoding construction reaches n^1.317 for triangle-free grid sets","Carry-free Gaussian construction gives n^1.3 grid triangle avoidance"],"cache_read_input_tokens":2304,"weakest_assumption_plain":"The whole construction depends on the 281-point list in Appendix A really having the claimed peeling property and being IRT-carry-free, as checked by the Python script in Appendix B; any bug in that script or mis-transcription of the list would invalidate the theorem.","fun_headline_variants_meta":{"raw":{"variants":["Gaussian digit peeling builds n^1.3 triangle-free grid subsets","First superlinear bound for grid sets without isosceles right triangles","New digit-encoding construction reaches n^1.317 for triangle-free grid sets","Carry-free Gaussian construction gives n^1.3 grid triangle avoidance"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.001324,"raw_usage":{"total_tokens":5167,"prompt_tokens":626,"completion_tokens":4541,"prompt_tokens_details":{"cached_tokens":256},"prompt_cache_hit_tokens":256,"prompt_cache_miss_tokens":370,"completion_tokens_details":{"reasoning_tokens":4462}},"tokens_in":370,"tokens_out":4541,"duration_ms":31046,"temperature":1.0,"reasoning_tokens":4462,"cache_read_input_tokens":256,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-01T04:23:00.146711+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Run the provided verifier on the 281-point list: if it reports any failed assertion — for example, a digit c in a remaining suffix for which a=(1+i)p_t−ic is also in the suffix with (a,c) not equal to (p_t,p_t), or a nonzero carry δ divisible by β — the construction collapses. A direct search over the encoded set A_m for a nondegenerate solution of a+ic=(1+i)b would also disprove the claim.","supporting_citations":[],"review_version":1}