This page is the primary record of the modular Schur project: what is proven, what is machine-verified, what has been computed, what has been refuted, and what is open. It is updated as the research state changes rather than frozen at publication, so a claim’s status here supersedes any statement in the PDF.

Every claim below carries a status label. Proven means a complete proof exists and has been audited. Verified means the Lean kernel checks it and the axiom closure has been inspected. Certificate means a solver certificate established it in the private working tree; the certificate chain is not distributed and has not passed the public axiom audit, so it is not Proven. Empirical means a solver established it for specific parameters and nothing more. Conjecture means it is believed but unproven. Refuted means it was believed and is now disproven. Those are kept on the page deliberately.

The main theorem

For a modulus m, write S_m(k,\ell) for the largest N such that \{1,\ldots,N\} admits a k-partition into sets containing no solution to x_1 + \cdots + x_\ell \equiv y \pmod m, where x_1,\ldots,x_\ell and y all lie in the same class and repetitions among the x_i are allowed. This is the IsEllSumFree convention: \ell addends and a separate target.

Proven For all m \ge 2, \ell \ge 2, and k \ge m/\gcd(m,\ell-1) - 1,

S_m(k,\ell) = \frac{m}{\gcd(m,\ell-1)} - 1.

Verified The Lean statement is schurModResidue_eq in lean/ModularSchur/Partition.lean. The ModularSchur tree contains no sorry.

Figure 1  ·  The residue collapse

m = 12, ℓ = 5

0 1 2 3 4 5 6 7 8 9 10 11 n

The criterion

A singleton \{r\} is \ell-sum-free exactly when

(\ell - 1)\,r \not\equiv 0 \pmod m


So the unsafe residues are a subgroup

d = \gcd(12,4) = 4, so n = 12/d = 3 and the annihilated residues are \langle 3\rangle = \{0,3,6,9\}, hatched above.

The hatched residues are the ones \ell - 1 annihilates. They form the subgroup of order d, so the first obstruction sits at n, and 1, \ldots, n-1 are each safe alone. That is the whole theorem in one picture: put each of them in its own class, and n can go nowhere.

Formalization status

Twelve structural results are configured for the Comparator gate in Lean 4, on toolchain leanprover/lean4:v4.35.0-rc3 with Mathlib pinned at c55e6e78 (the Mathlib tag v4.35.0-rc3). On 2026-10-06 the coset-cardinality claim was removed from the compared set at the Palomar review’s request; it remains a project-only result.

They are checked through a comparator gate, which exists to stop a formalization from proving something weaker than it appears to. Each theorem is stated twice: once in comparator/Challenge.lean using only Mathlib definitions, with the proof left as sorry, and once in comparator/Solution.lean where it is proved from this project’s development. The comparator checks that the two elaborated declarations carry the same statement, so the Lean statement cannot quietly drift toward the project’s own convenient definitions. It then checks the permitted declaration and axiom boundary and replays the proof exports through the configured kernels. The source files are not byte-identical, and nothing compares them as bytes. The sorrys in Challenge.lean are the design: they are the twelve holes the gate fills.

The conformance workflow also runs lake build ModularSchur.PublicAxiomAudit, which builds ModularSchur.PublicAxiomAudit, a #print axioms module for the broader project-only layer. That build elaborates the named declarations and surfaces their transitive axiom closures in the CI log for review; it does not automatically enforce a whitelist or fail merely because a custom axiom appears. This is independent of the Comparator/nanoda gate, whose scope is exactly the twelve ComparatorClaims declarations.

Verified The preceding 12-declaration gate most recently passed on public commit 315337d (run 33447037510, 2026-08-31 UTC). That run exercised the then-current 12-declaration comparator package, Lean 4.33 toolchain, pinned workflow, and both configured kernels. The thirteen-declaration Comparator job passed in run 33534800665 at public commit 5ca1063ec835e7f65d937395e7c227833f0a89ce, but the companion conformance job failed while building ModularSchur.PublicAxiomAudit. That failure must be repaired and the complete workflow rerun before public release. The build stamp in the page footer is the commit of the private source tree the public tree is synced from, not a public-repository SHA. The gate fails the build on any of: a sorryAx in the closure, an axiom outside {propext, Classical.choice, Quot.sound}, a generated native-evaluation axiom such as declaration._native.native_decide.ax_*, or a Challenge/Solution statement mismatch. A second job replays the proofs through Lean’s kernel and the independent nanoda and con-ron kernels.

The runs cited above used leanprover/comparator at its tag v4.33.0 (commit 3927ad383f208ae977c340a91c48ac9b497d2097), pinned by commit in CI. Since 2026-10-05 the comparator job instead runs lake comparator, which ships with the pinned Lean toolchain together with the exporter and the nanoda and con-ron kernels, so no part of the judge is built from a separate pin. It builds and exports Challenge and Solution inside its own bubblewrap sandbox. No run of this job is recorded here yet. The current twelve-declaration set differs from the preceding 12-declaration gate.

Figure 2  ·  The comparator gate

One theorem, stated twice

Challenge.lean

Mathlib definitions only.
Proof left as sorry.

Solution.lean

The same signature.
Proved from ModularSchur.

The two elaborated declarations must carry the same statement

so the Lean statement cannot drift toward the project’s own convenient definitions

Lean 4 kernel

Axiom closure inspected.

nanoda + con-ron

Two independent kernels replay every proof.


The gate fails the build on any one of these

a sorryAx anywhere in the closure

a generated native-evaluation axiom such as declaration._native.native_decide.ax_*

an axiom outside the permitted three

a Challenge/Solution mismatch

The gate exists to stop a formalization from proving something weaker than it appears to. Because the two elaborated statements must match, the Mathlib-only statement is the one that is actually proved.
Theorem Content Source
ComparatorClaims.schurMod_integerClosedForm the main theorem, over \mathbb{N} IntegerBridge.lean
ComparatorClaims.schurMod_integerCap_isGreatest maximality of the bounded integer search IntegerBridge.lean
ComparatorClaims.noValidIntegerPartition_of_ge_modulus nothing survives at N \ge m IntegerBridge.lean
ComparatorClaims.schurMod_integer_eq_residue integer-to-residue reduction IntegerBridge.lean
ComparatorClaims.schurModResidue_closedForm the main theorem, residue form Partition.lean
ComparatorClaims.schurModResidue_upperBound upper bound Partition.lean
ComparatorClaims.schurModResidue_lowerBound lower bound Partition.lean
ComparatorClaims.singleton_sumFree_iff_nonzeroMultiple singleton safety criterion SingletonSafety.lean
ComparatorClaims.criticalResidue_isUnsafe the residue n is itself unsafe UnifiedValue.lean
ComparatorClaims.zeroMem_notSumFree the zero residue is never safe UniversalBound.lean
ComparatorClaims.schurModResidue_oneColorClosedForm_of_le_modulus k=1, for 2 \le \ell \le m: \min(\ell-1, \lfloor m/\ell \rfloor) K1Theorem.lean
ComparatorClaims.schurModResidue_oneColorClosedForm complete k=1 formula for every \ell \ge 2 K1Theorem.lean

The coset cardinality bound sigmaInfty_le in SigmaInfty.lean (if every pairwise difference in C is divisible by one g \ge 2 dividing m, then \lvert C\rvert \le m/\mathrm{minFac}(m)) is a project-only result and is not compared. The paper-side theorem that places every stable safe set of size at least 2 under that divisibility hypothesis (Theorem 8.1) is prose, not Lean; its formalization is deferred, and the Lean statement carries the hypothesis explicitly.

The main theorem as Lean sees it, with no project-specific definitions in the statement:

theorem ComparatorClaims.schurMod_integerClosedForm (m k ℓ : ℕ) (hm : 2 ≤ m) (hℓ : 2 ≤ ℓ)
    (hk : m / Nat.gcd m (ℓ - 1) - 1 ≤ k) :
    Nat.findGreatest
      (fun N => ∃ P : Fin k → Finset ℕ,
        (∀ x ∈ Finset.Ioc 0 N, ∃ i, x ∈ P i) ∧
        (∀ i j, i ≠ j → Disjoint (P i) (P j)) ∧
        (∀ i, P i ⊆ Finset.Ioc 0 N) ∧
        (∀ i, ∀ f : Fin ℓ → ℕ, (∀ a, f a ∈ P i) → ∀ y ∈ P i, (∑ a, f a) % m ≠ y % m))
      (m - 1) = m / Nat.gcd m (ℓ - 1) - 1

Current project-only research layer

Verified Separate from the twelve-theorem comparator gate, the curated public ModularSchur aggregate now imports the canonical-block, support-one seed, residual-transport, and critical-core modules. Independent theorem-closing audits certify the seed-count package and the final recurrence, fresh-prime, prime-power, and unrestricted critical-core consumers. Their axiom closures contain only propext, Classical.choice, and Quot.sound. The generalized transport helpers compile and feed that consumer chain; they did not each receive a separate statement-fidelity audit. The public project-only module closure contains no proof placeholder, custom axiom, native_decide, unsafe or partial declaration, or external implementation.

The resulting project-only theorem packages prove:

  • the closed cardinality K_seed(n,a) of the support-one seed labels and the exact decomposition of the canonical cover into that seed count plus the residual cover;
  • for n ≠ 0, a prime p, and a_p ≤ v_p(n), exact transport of residual points and nonempty residual neighborhoods under n → pn, invariance of the residual cover number, and κ(pn,a) = κ(n,a) + (p−1)p^(a_p); a fresh prime is the depth-zero case and contributes p−1;
  • for every n ≠ 0 and arbitrary depth data, the unrestricted reduction to the exponent-truncated critical core together with the closed contribution from all removed exponent layers.

These packages are not among the twelve comparator declarations. They are distributed and axiom-audited as a separate project-only layer; the comparator does not compare their statements. They close the exponent-tail bookkeeping, not the universal tau problem. The remaining project-wide frontier is the cover theory on the exponent-truncated critical domain. The active AS/FD-6 Lean lane has closed and independently audited its shared W0 window and W1 support layers; W2 is next, W3 is the highest-risk modular-unit relabeling bridge, and W4/A1–A3/F1–F3 remain open. The older producer of TwoAxisCertificateShape cell P from P.card = 2 and genuinely multi-axis obstruction theory also remain open.

The audit boundary

An earlier computational route to some of these results lives in a generated tree of 7,585 Lean files (36 MB), of which 1,735 use native_decide. That route is excluded from the gate and is not part of the verification claim above: native_decide trusts the compiler rather than the kernel, so its closure carries a generated per-computation native-evaluation axiom named like declaration._native.native_decide.ax_*.

Verified The twelve theorems do not depend on that tree. Solution.lean imports only IntegerBridge and K1Theorem; the resulting import cone reaches Basic, Partition, SingletonSafety, UniversalBound, UnifiedValue, UnifiedTheorem, and StableRange, and contains zero occurrences of native_decide. The structural proof subsumes the computational one; the generated tree is retained as history, not as evidence.

The public repository carries that nine-module comparator cone and a separate project-only allowlist of hand-written, generated-independent modules. The second layer now includes SameSupportFiber.lean, CoordinateUnion.lean, WholeAxisPID.lean, AnchoredExactTransversal.lean, and the canonical seed/transport/critical-core package. These modules are distributed and have a separate axiom audit, but they are not inside the twelve-declaration comparator gate. The gate claim remains confined to the import cone above. The conformance workflow runs lake build ModularSchur.PublicAxiomAudit to elaborate the project-only declarations and log their transitive #print axioms closures for review; that build does not itself whitelist-fail on custom axioms. On 2026-08-24 the author ran #print axioms for the five Section 8 declarations SameSupportFiber.coordinateUnionEdgeRule_on_normalizedCell, WholeAxisPID.axis_cover_coordCliques_eq_card_of_forall_PID, AnchoredExactTransversal.axis_cover_eq_maxPacking_of_hasCarrierAET, TauClosure.tau_capstone, and TauClosure.tauDPRec_characterization; each closes to {propext, Classical.choice, Quot.sound}. That measurement was made by the author’s tooling on the private tree, is not part of the public gate, and leaves the Certificate label this page gives the Section 8 results unchanged. See the errata.

Figure 3  ·  The audit boundary

What the verification claim covers

Inside the gate

The structural route

Kernel-checked. This is the verification claim.

Basic   Partition   SingletonSafety
UniversalBound   UnifiedValue
UnifiedTheorem   StableRange
IntegerBridge   K1Theorem

Axiom closure

propext
Classical.choice
Quot.sound

✓ zero occurrences of native_decide

Excluded

The generated tree

Retained as history, not as evidence.

7,585

Lean files

1,735

use native_decide

Axiom closure

declaration._native.native_decide.ax_*

× trusts the compiler, not the kernel

The two routes reach some of the same results. Only the left one is claimed. The structural proof subsumes the computational one, so nothing is lost by drawing the line here, but the line has to be drawn, and stated.

Computational coverage

Direct SAT tables

scripts/schur_mod.py encodes S_m(k,\ell) as SAT and drives CaDiCaL. It has two modes. In certified mode (--certified) every UNSAT boundary must emit a DRAT proof that drat-trim replays, and the run fails closed when the proof or the checker is missing. The default exploratory mode may answer from an in-process solver with no certificate; its results are tabulations, not certificates.

Empirical Full grids computed for m = 8, 9, 10, 11, 12, 13 over k \le 12 and \ell \le 12, with probes out to \ell = 25. The encoder was validated first against the published values of D’orville et al. for m \in \{4,5,6,7\}, k \le 6, \ell \le 8 (168 cases, zero mismatches) and against brute force on 540+ small instances.

The full run produced 10,712 CNF/proof/solution triples spanning m \le 18, k \le 17, \ell \le 54. These artifacts are not distributed: they are local and gitignored. Only the boundary rows recorded in the phase tables carry an explicit proof_verified replay result. Treat the grids as reproducible rather than as shipped certificates.

The residual frontier program

Beyond the stabilized law, the project computes the threshold in the stable regime. For \ell \ge m-1 the safety of a class depends only on c = \ell \bmod m (the large-\ell coset criterion, the prose Theorem 8.1 named under sigmaInfty_le above), so k_0(m,\ell) is a function of (m,c) there; write k_0^\infty(m,c) for that value. It is this stable threshold, not the ordinary k_0(m,\ell), that is a function of the normalized cell; the paper’s Section 8 has stated the schema for k_0^\infty since its 2026-08-24 revision (the earlier form is recorded in the errata). The method caps each prime exponent of d, collapsing infinitely many moduli onto finitely many normalized cells, so an infinite family closes by a finite check.

Certificate-backed computation; public audit incomplete. The two results below rest on solver certificates and certificate theorems that live in the private working tree. They are not among the twelve gated theorems, the artifacts are not distributed, and the certificate sweep has not passed the axiom audit, so they carry the Certificate label, not Proven.

Certificate By finite normalized-cell reduction. 56 fixed-quotient lines (n = 36 through n = 345), each with per-cell certificates, governed by three capstone theorems. Stable laws for the families m = 36t (d=6), 72t (d=12), 72t (d=6t), 100t (d=10), 144t, 196t, 216t, 252t, 360t, computationally reproduced to t \le 500.

Certificate By explicit certificate. The rows those families do not cover are handled individually: 40 packing-gap rows for 8 \le m \le 60, then residual covers at successive frontiers.

The m \le 5500 scan reports zero residual rows. What that means, exactly: phase9_stable_tables.py --scan-residual-frontier 5500 computes \sigma^\infty and k_0^\infty for every row 8 \le m \le 5500, 1 < d < m, then drops three classes of rows before printing: rows with k_0^\infty \le \lceil (n-1)/\sigma^\infty \rceil, rows whose private-fragment certificate covers the cell by itself, and rows on a list of residual rows discharged in earlier phases that is hard-coded in the script (is_known_residual_row). Zero means that no row falls outside those three classes. The scan does not re-verify the earlier discharge of the listed rows. A coverage manifest (--coverage-manifest, in the public scripts/phase9_stable_tables.py) lists every scanned row with the rule that discharged it; it records coverage, not verification, and no row-to-certificate manifest is published.

This is a statement about the stable regime \ell \ge m-1 and about k_0^\infty, not about the main theorem, which is unconditional and needs no computation.

Verification debt

Not everything computed is machine-checked to the standard of the twelve gated theorems. The certificate-theorem sweep over the m \le 5500 frontier has not been run through the axiom audit. tauDPRec_characterization has one recorded axiom closure, the author’s 2026-08-24 measurement on the private tree ({propext, Classical.choice, Quot.sound}; see the audit boundary); the public gate has not measured it. Those results rest on their solver certificates, not on a kernel-checked Lean proof. The coverage manifest names, for each frontier row, the rule or phase that discharged it, but nothing public maps a row to a replayed certificate: no row-to-certificate manifest exists.

Open questions

The threshold k_0(m,\ell)

The main theorem says what S_m(k,\ell) equals once k is large enough. The threshold, the least k at which the stable value is reached, is the open half of the problem.

Write n = m/\gcd(m,\ell-1) and let \sigma(m,\ell) be the largest size of a safe subset. Proven: k_0 \le n-1 when d < m, and, for n \ge 2, k_0 \ge \lceil (n-1)/\sigma \rceil. The lower bound needs n \ge 2: at \ell \equiv 1 \pmod m one has n = 1, the interval is empty and \sigma = 0.

For prime modulus the threshold is settled exactly, but only inside the hypotheses of the paper’s corollary: if p is prime, \ell \ge p-1, and \ell \not\equiv 1 \pmod p, then \sigma(p,\ell) = 1 and k_0(p,\ell) = p-1. That value is not new: under the same hypotheses, Corollary 8 of D’orville et al. gives S_p(k,\ell) = k for 1 \le k \le p-1 and S_p(k,\ell) = p-1 for k \ge p-1, so the stable value is first reached at k = p-1. What the paper adds is a second proof, by sumset saturation; since its 2026-08-24 revision the abstract says so and cites Corollary 8. Outside that range the threshold can be much smaller. At p = 5, \ell = 2 the partition \{1,4\} \sqcup \{2,3\} is safe, so k_0(5,2) = 2 rather than 4 (D’orville et al., Theorem 9: S_5(k,2) = 4 for k = 2, 3).

Figure 4  ·  The open threshold

k_0(m,\ell)

⌈(n−1)/σ⌉ n − 1 Proven Proven open

And the natural conjecture is false at composite moduli

Take m = 12 and any \ell \equiv 11 \pmod{12}, so d = 2 and n = 6. The pair C = \{1,5\} is \ell-safe, so \sigma \ge 2. Such \ell are arbitrarily large.

0 1 2 4 k₀ ≤ 3 3 n−1 = 5 5
Both ends of the bracket are proven and nothing closes the interval between them. At m = 12 the upper end collapses to 3, so no L(12) exists beyond which k_0 = n-1. The replacement law is coset-theoretic rather than singleton-based, and finding it is the open half of the problem.

The natural conjecture is false at composite moduli. One might expect that for each m there is an L(m) beyond which k_0(m,\ell) = n-1 whenever d < m. Take m = 12 and any \ell \equiv 11 \pmod{12}, so d = 2 and n = 6. The pair C = \{1,5\} is \ell-safe: H_C = \langle 4\rangle has order 3, g_C = 4, and safety needs 4 \nmid 10. Directly, 11 \cdot \{1,5\} = \{3,7,11\}, disjoint from \{1,5\}. So \sigma \ge 2 and k_0(12,\ell) \le 3 < 5 = n-1. Such \ell are arbitrarily large, so no L(12) exists. The argument generalizes to any composite m with a suitable proper divisor; the correct replacement is coset-theoretic rather than singleton-based.

A second natural guess, k_0^\infty = \lceil (n-1)/\sigma^\infty \rceil for d > 1, is also refuted, first at m = 16, where \sigma^\infty = 2 gives a bound of 4 but the true value is 5.

Open The general d > 1 law that replaces it. The frontier program above establishes it row by row out to m \le 5500 without yielding a closed form.

Also open

  • A closed form for \sigma^\infty(m,c) as a function of (m,c), rather than a maximum over subsets.
  • The boundary regime 1 \le k < n-1. No unified formula; per-row eventual periodicity in \ell is conjectured, supported by the tables for 8 \le m \le 13.
  • \sigma(m,\ell) = \max\{\lvert H\rvert : H < \mathbb{Z}/m proper, \ell H \cap H = \varnothing\}. Conjecture.
  • A universal closed form for \tau, the residual minimum set cover. Open. Exponent-tail stripping is now proved in Lean, so the live problem is the exponent-truncated critical domain. Anchored exact transversals remain useful certificates for individual fibers but do not supply a universal route.

Erdős problem 483

This project does not address Erdős problem 483. The problem asks for the growth rate of the Schur numbers, whether f(k) < c^k, which no finite computation resolves. It is not the determination of S(6).

S(6) itself is unknown, with 536 \le S(6) \le 1836; the lower bound has stood since 2000. A recon pass on it concluded it was not a productive target for this project and it was abandoned. One lead was noted and not pursued: since h(r) \le f(r) and f(6) = S(6), any modular sum-free 6-colouring of [N] modulo N+1 certifies S(6) \ge N.

A planned Rado-number thread was never executed; the material that exists is a landscape memo, not a result.

D’orville et al. problems

This work engages two parts of Problem 1 of the originating paper. The numbering was checked against the published original on 2026-08-24 (Integers 25 (2025), #A62, Problem 1): part 3 asks for S_m(1,\ell) when 2 < \ell < (m+1)/2 and m \ge 8; part 5 asks for S_m(k,\ell) when m \ge 8. Part 3, the values of S_m(1,\ell) for 2 < \ell < (m+1)/2, m \ge 8, is closed by this work as S_m(1,\ell) = \min(\ell-1, \lfloor m/\ell \rfloor), formalized as schurModResidue_k1. Part 5’s large-k regime is settled by the main theorem. The parts not named here are not addressed by this work.

Refuted and retracted

These were working hypotheses in this project and are now known false. They stay on the page with their refuting evidence, because the cost of a dead end is paid twice if it is not recorded.

The anchored exact transversal route

Write \nu for the maximum packing and \theta for the axis cover of a fiber’s conflict structure. The anchored exact transversal hypothesis (AET) asserted \theta = \nu: that the cover is always tight.

Figure 5  ·  The Coordinate-Union Edge Rule

G_{\mathrm{atom}}[X_P]

cliques along the first axis g1 cliques along the second axis g2 the union: the atom graph on XP A B C D E F

One axis, one partition

Fix an axis g \in P. Atoms that share their residue \rho_g are pairwise adjacent, so each axis partitions the fiber into cliques, singletons included.


Union over the axes

The atom graph has an edge exactly when the two atoms share a residue on some axis of P. Every edge keeps the color of the axis that produced it.


Why it matters here

A separated fiber has singleton cliques on every axis, so the graph is edgeless: the whole fiber is a packing and the cover is exact. The deficit \theta - \nu can only live where cliques overlap.

Six atoms in a |P| = 2 fiber. The first axis contributes the cliques \{A,B\} and \{E,F\}, the second \{A,F\}, \{C,D\} and \{B,E\}, and the atom graph is the union of both edge sets. With motion enabled the figure cycles through the two axes and then their union; with reduced motion it shows the union.

Refuted On 2026-04-26, and independently re-certified on 2026-06-20, eight non-dyadic counterexamples closed the universal form. The cornerstone cases are n = 330 and n = 660, where \nu = 13 and \theta = 14.

The hypothesis was then narrowed to dyadic fibers, where it held across every case scanned. That restriction is also refuted (2026-06-21), by a single certified fiber:

n = 880,\quad d_0 = 35200,\quad P = (121,\,125,\,256) = (11^2,\,5^3,\,2^8)

with \nu = 48 and \theta = 50. The fiber is dyadic (880 = 55\cdot 2^4, no power of three anywhere), singleton-atom, PID-failing, and sub-saturating. The bounds are certified by cvc5 (maximum packing \ge 49 UNSAT, cover \le 49 UNSAT, cover of size 50 SAT), cross-checked against Z3 and CaDiCaL, with the encoding smoke-tested against the known n = 1716 and n = 330 results first.

What survives. The implication certificate shape \Rightarrow exactness is untouched and remains fully proved in Lean. What the counterexample removes is the claim that the shape disjunction is universal: that every PID-failing fiber has one of those shapes. Each individual shape still forces \theta = \nu. These are different statements and the second is not in question.

Other closed routes

Route How it failed
Perfectness of the conflict graph via odd-hole classification 11 explicit induced C_5 subgraphs in dyadic \lvert P\rvert = 3 conflict graphs
Bounded atom treewidth as a universal method treewidth grows: 15 at n=220, 21 at n=440, 36 at n=880
An arithmetic invariant on (n, d_0, P) separating AET-holds from AET-fails no such invariant exists at that granularity; the same (d_0, P) holds at n = 1760 and fails at n = 880
Whole-fiber packing law for the deficit false: the gap-0 fiber n = 660 contains 222 vertex-critical gap-1 cores, so deficit < packing
Six pre-declared LP optimal-face activity selectors none reproduces the integer deficit across a 12-fiber, 6,969-vertex census
Universal incidence-width bound \le 26 replayed certificates give 27 \le \mathrm{tw} \le 89 at the n = 7040 probe
Growing-minor lower bound along the (121,125,256) family an artifact of labeling; the four incidence graphs at n = 7040, 14080, 28160, 56320 are isomorphic under x \mapsto 2x

Retracted for solver error

Two reported dyadic AET failures, at n = 1760 and n = 3520, were false positives, caused by a maximum-independent-set routine that under-counted. AET in fact holds at both (\nu = \theta = 16). Six of fourteen reported non-dyadic failures came from the same defect and were withdrawn. The counterexamples that survive, including n = 880 above, were re-certified with the corrected procedure and by an independent audit path.

This is why the n = 880 result carries a cvc5 certificate and a second-solver cross-check rather than a scan report.

Errata in the paper

The paper and the PDF are the canonical text and are corrected only by their author. The statements below were wrong or under-scoped in the paper before its revision of 2026-08-24; each was checked against the source text and, where it is a computation, recomputed for this page. All of them are corrected in the current paper and PDF, whose Revision history section lists the changes; the entries stay here as the record of what was wrong and why.

Section 8, the K + \tau display. The paper wrote k_0(m,\ell) = K(d_0) + \tau(d_0) for the ordinary threshold and for any \ell with quotient n. As written that is false: (m,\ell) = (5,2) and (5,3) have the same d = 1, n = 5, d_0 = 1, but k_0(5,2) = 2 (\{1,4\} \sqcup \{2,3\} is safe) and k_0(5,3) = 4 (every two-element subset of \{1,2,3,4\} is unsafe for \ell = 3, so only singletons reach N = 4). Both values are in D’orville et al., Theorem 9. The quantity that depends only on the normalized cell is the stable threshold k_0^\infty(m,c) defined under the residual frontier program, and that is what the frontier scan computes (exact_k0_inf in phase9_stable_tables.py enumerates stable-regime safe sets). Section 8 now defines k_0^\infty and states the schema and the frontier for it; the remaining bare k_0 in Sections 8 and 9 refer to the ordinary threshold on purpose.

Abstract and Figure 8 caption: the prime threshold without its hypotheses. Both stated k_0(p,\ell) = p-1 with no hypotheses. The corollary in Section 5 has them, \ell \ge p-1 and \ell \not\equiv 1 \pmod p, and without them the claim is false: k_0(5,2) = 2. The abstract also presented the value as pinned down by this paper; under those hypotheses it follows at once from D’orville et al., Corollary 8, and the paper’s contribution is a second proof (see the threshold). Both statements now carry the hypotheses and the abstract cites Corollary 8.

Section 9, open problem 3 (optimizing over \ell). The paper said the pointwise value of S_m(k,\ell) at fixed k is supplied by the main theorem, so that maximizing over \ell is a divisor-counting problem. The main theorem applies only for k \ge n-1, and n depends on \ell. At m = 100, k = 1 the one-color theorem gives S_{100}(1,10) = \min(9, 10) = 9, while the main theorem at k = 1 covers only the \ell with n \le 2, where it gives at most 1. At fixed k the maximum over \ell is governed by the boundary regime 1 \le k < n-1, which is open (see Also open). The item now says so.

Section 5, the covering lower bound. Was stated without n \ge 2. At \ell \equiv 1 \pmod m one has n = 1, the set \{1,\ldots,n-1\} is empty, \sigma(m,\ell) = 0, and \lceil (n-1)/\sigma \rceil is undefined. The bound holds for n \ge 2, as stated on this page and now in the theorem.

Section 5, the gloss after the upper bound. The theorem says k_0(m,\ell) \le \max(1, n-1); the sentence after it said one never needs more than n-1 classes. At n = 1 the threshold is 1, not 0; the gloss now says so.

Figure 8 (saturation over a prime modulus). The caption said the sumsets of C = \{1,3\} \subseteq \mathbb{Z}/5 grow as 1C \subset 2C \subset \cdots. They do not: 2C = \{1,2,4\} does not contain 3 \in 1C. The chain is nested for D = C - a_0, which contains 0, and D is the set the proof uses. The caption now states the growth in size (which holds by Cauchy–Davenport) and names the shift; the panels, which show \ell C itself, were correct and are unchanged.

Section 6, the empirical count. The range 2 \le m \le 30, 2 \le \ell \le m has \sum_{m=2}^{30}(m-1) = 435 pairs; the paper said 414. All 435 agree with \min(\ell-1, \lfloor m/\ell \rfloor) (recomputed for this page), so the error was in the count only; the paper now says 435.

Section 8, coordinate terminology. Atoms were said to carry one coordinate per prime g in their support pattern. The labels are not always prime; the paper’s own axis tuples include 121, 125, and 256. The paper now says “axis label”.

Section 1, the formalization sentence. The paper once said the main theorem, the k = 1 case, and the structural reductions of Section 8 were all in the public development. The 2026-08-24 paper revision narrowed that sentence to the ten-module comparator cone and called the Section 8 modules private and ungated. The 2026-08-29 Lean-only public release later distributed those modules, without changing the paper. They remain outside the comparator gate; the status record and LEAN_STATUS.md now carry the current boundary.

Reproduction

Lean. Toolchain leanprover/lean4:v4.35.0-rc3, Mathlib pinned at c55e6e78 (tag v4.35.0-rc3) in lean/lake-manifest.json.

cd lean
lake build
lake build ModularSchur.PublicAxiomAudit

Scans. Require uv and CaDiCaL; drat-trim for certificate checking. The headline computational claims map to these exact invocations:

Claim Command
168 literature cases and 540+ brute-force checks uv run scripts/schur_mod.py validate
m \le 5500 residual-frontier closure uv run scripts/phase9_stable_tables.py --scan-residual-frontier 5500 --jobs 1
56 fixed-quotient family lines one --scan-n<N>-fixed-quotient-family flag per family on scripts/phase9_stable_tables.py; --help lists them all
10,712 CNF/proof/solution triples regenerable, not shipped: the grid driver in scripts/schur_mod.py re-creates them (--help for the grid flags); no checksums are published, so a re-run is a re-computation, not a verification of the original artifacts

The full certificate tree is roughly 121 GB and is not distributed; scripts/schur_mod.py regenerates it deterministically.

Provenance

The quantity S_m(k,\ell) was introduced by Chappelon et al. (2013). The problems this work engages with are posed by D’orville, Sim, Wong, and Ho, Integers 25 (2025) #A62 (published version). The D’orville et al. attribution, theorem numbers, and problem numbering cited on this page were checked against that published version on 2026-08-24, and the Chappelon et al. attribution against Electron. J. Combin. 20(2) (2013), #P61 (arXiv:1306.5635) the same day; formalization.yaml and docs/references/ record both checks.

Multiple AI-assisted workflows contributed under human direction. Claude (Anthropic), driven through Claude Code, contributed to the original structural development, comparator packaging, documentation, and paper draft. Aristotle (Achim et al., 2025, arXiv:2510.01346) filled the proof bodies of 10 lemmas identified by trailers on commits e07bf41 and 7c56323. OpenAI Codex/GPT-5 contributed to later canonical project-layer work, trust hardening, public audit and release tooling, and documentation. Because Git does not reliably record model or session attribution for every file, no finer per-file claim is made beyond the Aristotle trailers. Every published declaration is kernel checked as described under Formalization status.

Author: A. McKenna, 2026.