Skip to content

feat(coding-theory): constructors for the Grand List-Decoding witnesses - #792

Open
aryaethn wants to merge 2 commits into
Verified-zkEVM:mainfrom
aryaethn:feat/grandchallenges-list-witnesses
Open

feat(coding-theory): constructors for the Grand List-Decoding witnesses#792
aryaethn wants to merge 2 commits into
Verified-zkEVM:mainfrom
aryaethn:feat/grandchallenges-list-witnesses

Conversation

@aryaethn

Copy link
Copy Markdown
Contributor

Summary

GrandChallenges.lean defines ListLowerWitness and ListUpperWitness for the Grand
List-Decoding Challenge, together with the boundary lemmas relating them to a
GrandListResolution — but ships no constructor for either, so neither side of the
challenge could be witnessed for any concrete code. (The MCA side, by contrast, has three
McaLowerWitness constructors.)

This adds four constructors, all axiom-clean.

What's added

In GrandChallenges.lean — the generic shapes, mirroring the existing
McaLowerWitness.ofLe / McaUpperWitness.ofGt:

  • ListLowerWitness.ofLe
  • ListUpperWitness.ofGt
  • ListUpperWitness.ofEncardGt — reduces an unsafe witness to a single word with an
    oversized point list. Lambda is a supremum over words, so one such word suffices, and this
    is the shape a concrete large-list construction actually produces.

In the new GrandChallenges/ListDecoding.lean — the two substantive ones:

constructor radius reached supporting lemmas
ListLowerWitness.ofUniqueDecodingRange relative unique-decoding radius relUDR_interleavedCode_eq, lambda_interleavedCode_le_one_of_le_relUDR
ListLowerWitness.ofJohnsonBound Johnson radius lambda_interleavedCode_le_of_le_johnson

The unique-decoding one is the floor, mirroring McaLowerWitness.ofUniqueDecodingRange:
interleaving preserves minimum distance (Code.minDist_interleavedCodeSet), hence the
unique-decoding radius, and inside that radius the interleaved point lists are subsingletons
(Code.isUniquelyDecodable_relativeUniqueDecodingRadius), so Λ(C^⋈m, δ) ≤ 1.

The Johnson one reaches much further. CodingTheory.johnson_bound_lambda_le_ell is stated over
an arbitrary finite alphabet, so it applies to C^⋈(Fin m) at alphabet Fin m → F with no
specialization; the supporting lemma re-expresses its two code-dependent inputs on the base
code, so a caller can discharge the hypothesis with the C they actually hold.

Two points a reviewer may want to check

The Johnson radius is computed at q = |F|^m, not |F|. This is deliberate and is the
interleaved code's own alphabet. It widens the usable radius rather than narrowing it, since
q/(q-1) decreases in q, while the relative minimum distance is unchanged. The module
docstring records this so it is not later "corrected" to |F|.

The list side now has an admit-free Johnson-range witness where the MCA side does not.
McaLowerWitness.ofJohnsonRangeBound is sorry-tainted in scripts/axiom_baseline.json through
the external [BCHKS25] admit rs_mcaError_le_in_johnson_range. The list-side Johnson witness
rests on johnson_bound_lambda_le_ell, which is in-tree and axiom-clean, so it needs no admit.
Flagging this as a genuine asymmetry rather than leaving it to be noticed.

Provenance

axiomsweep --root ...GrandChallenges.ListDecoding
  5 declarations, sorryAx-tainted: 0, non-standard-axiom-tainted: 0

axiomsweep --root ...GrandChallenges
  214 declarations, sorryAx-tainted: 0, non-standard-axiom-tainted: 0

./scripts/validate.sh --axioms passes end to end: build, ArkLib/Data warning budget
(no non-sorry warnings), toy-problem runtime, umbrella imports, docs integrity, knowledge-base
lint, axiom-sweep fixture matrix, and the axiom/sorry regression baseline (no new taint).

What this does not do

  • No prize resolution. mcaPrize / listDecodingPrize remain unproved at every rate, and
    nothing here approaches them. Both new constructors bound Λ by a fixed , whereas a
    resolution needs Λ ≤ ε* · |F| — the obstacle is the shape of the bound, not the radius.
    Nothing outside GrandChallenges.lean instantiates prizeDimension / prizeRate at any
    j : Fin 4, so the rates 1/4, 1/8, 1/16 are still untouched.
  • No upper witness for a concrete code. ListUpperWitness.ofGt and .ofEncardGt are
    generic shapes awaiting a real large-list construction; ofEncardGt is the intended entry
    point for one.

docs/kb/papers/ABF26.md is updated to record the new constructors and to restate the
remaining gaps in these terms.

Note on style

The three new defs in GrandChallenges.lean write the interleaving as C^⋈(Fin m) without
spaces, which differs from the ~20 spaced C ^⋈ (Fin m) occurrences elsewhere in that file.
This is forced, not a preference: Mathlib's whitespace linter diffs source against the
pretty-printed form, and notation:20 C "^⋈" κ carries no spaces, so the spaced form warns —
and ArkLib/Data is under a zero-warning gate. The existing occurrences do not warn because
they sit in structure fields and theorem statements; these are the file's first defs using
the notation.

Closes #789

aryaethn and others added 2 commits August 22, 2026 00:57
…itnesses

`GrandChallenges.lean` carried `ListLowerWitness` and `ListUpperWitness` with no
constructor for either, so neither side of the Grand List-Decoding Challenge could
be witnessed for any concrete code.

Add, in `GrandChallenges.lean`:

- `ListLowerWitness.ofLe` and `ListUpperWitness.ofGt`, the generic shapes, mirroring
  the existing `McaLowerWitness.ofLe` / `McaUpperWitness.ofGt`.
- `ListUpperWitness.ofEncardGt`, reducing an unsafe witness to a single word with an
  oversized point list. `Lambda` is a supremum over words, so one such word suffices;
  this is the shape a concrete large-list construction actually produces.

Add, in the new `GrandChallenges/ListDecoding.lean`:

- `relUDR_interleavedCode_eq` and `lambda_interleavedCode_le_one_of_le_relUDR`,
  supporting `ListLowerWitness.ofUniqueDecodingRange` — the first constructor for
  either list witness type. Interleaving preserves minimum distance, hence the
  unique-decoding radius, and inside that radius the interleaved point lists are
  subsingletons, so `Λ(C^⋈m, δ) ≤ 1`.

The new module is axiom-clean (axiomsweep: 3 declarations, 0 tainted), as is all of
`GrandChallenges.lean` (214 declarations, 0 tainted). This mirrors
`McaLowerWitness.ofUniqueDecodingRange` on the MCA side and shares its trade-off: the
unique-decoding radius falls well short of the Johnson and capacity radii, so it is
not a route to the prize thresholds. A Johnson-radius list witness is reachable
without new admits, since `CodingTheory.johnson_bound_lambda_le_ell` is stated over an
arbitrary finite alphabet and is itself axiom-clean; that is left as follow-up work.

`docs/kb/papers/ABF26.md` records the new constructors and the remaining gaps, keeping
the two upper-witness items separate from the prize resolutions, which are the open
research question rather than a formalization backlog.

Refs Verified-zkEVM#789
…tness

`ListLowerWitness.ofUniqueDecodingRange` only certifies radii up to half the
minimum distance. Add `ListLowerWitness.ofJohnsonBound`, which reaches the
Johnson radius and is likewise admit-free.

`CodingTheory.johnson_bound_lambda_le_ell` is stated over an arbitrary finite
alphabet, so it applies to `C^⋈(Fin m)` at alphabet `Fin m → F` with no
specialization. `lambda_interleavedCode_le_of_le_johnson` re-expresses its two
code-dependent inputs on the base code: the alphabet size becomes `|F|^m`, and
the minimum distance is unchanged (`Code.minDist_interleavedCodeSet`). Stating
the radius on `C` rather than on the interleaved code is what makes the
constructor usable, since a caller has `C` in hand.

The Johnson radius is computed at `q = |F|^m`, not `|F|`. That widens the usable
radius rather than narrowing it, since `q/(q-1)` decreases in `q`, while the
relative minimum distance is untouched. The module docstring records this so it
is not later "corrected" to `|F|`.

Both list witnesses are axiom-clean (axiomsweep: 5 declarations, 0 tainted).
Note the asymmetry with the MCA side: `McaLowerWitness.ofJohnsonRangeBound` is
sorry-tainted through the external [BCHKS25] admit
`rs_mcaError_le_in_johnson_range`, whereas the list-side Johnson witness rests
on an in-tree axiom-clean bound.

`docs/kb/papers/ABF26.md` is corrected accordingly: the previous gap note said
no list witness reached past the unique-decoding radius, which this makes false.
The sharpened statement is that both constructors bound `Λ` by a fixed `ℓ`,
whereas a prize resolution needs `Λ ≤ ε* · |F|` — the obstacle is the shape of
the bound, not the radius.

Refs Verified-zkEVM#789

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
@chatgpt-codex-connector

Copy link
Copy Markdown

You have reached your Codex usage limits for code reviews. You can see your limits in the Codex usage dashboard.

@github-actions

github-actions Bot commented Aug 22, 2026

Copy link
Copy Markdown
Contributor

🤖 PR Summary

NO


Statistics

Metric Count
📝 Files Changed 4
Lines Added 239
Lines Removed 0

Lean Declarations

✏️ Added: 8 declaration(s)

ArkLib/Data/CodingTheory/ProximityGap/GrandChallenges.lean (3)

  • def ListLowerWitness.ofLe {C : Set (ι → F)} {m : ℕ} {ε_star δ : ℝ≥0}
  • def ListUpperWitness.ofEncardGt {C : Set (ι → F)} {m : ℕ} {ε_star δ : ℝ≥0}
  • def ListUpperWitness.ofGt {C : Set (ι → F)} {m : ℕ} {ε_star δ : ℝ≥0}

ArkLib/Data/CodingTheory/ProximityGap/GrandChallenges/ListDecoding.lean (5)

  • noncomputable def ListLowerWitness.ofJohnsonBound
  • noncomputable def ListLowerWitness.ofUniqueDecodingRange
  • theorem lambda_interleavedCode_le_of_le_johnson (C : Set (ι → F)) {m ℓ : ℕ}
  • theorem lambda_interleavedCode_le_one_of_le_relUDR (C : Set (ι → F)) {m : ℕ} (hm : 0 < m)
  • theorem relUDR_interleavedCode_eq (C : Set (ι → F)) {m : ℕ} (hm : 0 < m) :

sorry Tracking

  • No sorrys were added, removed, or affected.

📋 **Additional Analysis**

Two style violations: missing citation key in a docstring, and a remark about 'L2.10' using an author-year suffix. Everything else (title format, naming, syntax, docs) is clean.


📄 **Per-File Summaries**
  • ArkLib.lean: The diff adds an import statement for the new module ArkLib.Data.CodingTheory.ProximityGap.GrandChallenges.ListDecoding to the main ArkLib.lean file, making that module available as part of the library.
  • ArkLib/Data/CodingTheory/ProximityGap/GrandChallenges.lean: The diff adds three new constructor-style definitions that construct ListLowerWitness or ListUpperWitness objects from simpler hypotheses. ListLowerWitness.ofLe and ListUpperWitness.ofGt each take a radius δ ≤ 1 and a comparison of Code.Lambda (C^⋈(Fin m)) (δ : ℝ) against the threshold ε_star * Fintype.card F, producing the corresponding witness directly via the structure's single-constructor definition. ListUpperWitness.ofEncardGt provides a more primitive entry point: it takes a specific word f : ι → (Fin m → F) and a proof that the encard of its δ-close codewords relation exceeds the threshold, then uses the lemma Code.encard_closeCodewordsRel_le_Lambda to derive the required Lambda-based inequality and delegates to ListUpperWitness.ofGt. No sorry or admit are introduced.
  • ArkLib/Data/CodingTheory/ProximityGap/GrandChallenges/ListDecoding.lean: This new file adds two constructors for the existing ListLowerWitness type, which previously had none. It defines ListLowerWitness.ofUniqueDecodingRange, which provides a witness when the error rate δ does not exceed the relative unique-decoding radius of the base code C, using two new lemmas: relUDR_interleavedCode_eq (showing interleaving preserves that radius) and lambda_interleavedCode_le_one_of_le_relUDR (showing the interleaved list size is ≤ 1 in that regime). It also defines ListLowerWitness.ofJohnsonBound, which provides a witness when δ is at most the Johnson radius computed for the interleaved code's alphabet |F|^m and the base code's relative minimum distance, using the lemma lambda_interleavedCode_le_of_le_johnson that bounds the interleaved list size by . The file explicitly notes that no sorry or admit is used, unlike the analogous MCA-side constructor.
  • docs/kb/papers/ABF26.md: The diff adds a new documentation section describing GrandChallenges/ListDecoding.lean, which contains two axiom-clean ListLowerWitness constructors: ofUniqueDecodingRange (bounding Λ(C^⋈m, δ) ≤ 1 at the unique-decoding radius via interleaving's minimum-distance preservation) and ofJohnsonBound (reaching the Johnson radius using CodingTheory.johnson_bound_lambda_le_ell). It notes the asymmetry with the MCA side, where McaLowerWitness.ofJohnsonRangeBound depends on an external sorry-tainted admit. A separate new subsection documents that both prize propositions (mcaPrize and listDecodingPrize) remain unproved at all rates, with no McaUpperWitness or ListUpperWitness built for any concrete code, and that existing list lower bounds stop at fixed rather than the prize-required Λ ≤ ε* · |F|.

Last updated: 2026-08-22 06:38 UTC.

@github-actions

Copy link
Copy Markdown
Contributor

Build Timing Report

  • Commit: 6930b8d
  • Message: feat(coding-theory): constructors for the Grand List-Decoding witnesses
  • Ref: feat/grandchallenges-list-witnesses
  • Comparison baseline: df2339f from current base of main.
  • Measured on ubuntu-latest with /usr/bin/time -p.
  • Commands: clean build rm -rf .lake/build && lake build; warm rebuild lake build; validation wrapper ./scripts/validate.sh.
Measurement Baseline (s) Current (s) Delta (s) Status
Clean build 1199.10 1528.43 +329.33 ok
Warm rebuild 2.91 2.26 -0.65 ok
Validation wrapper 17.23 377.12 +359.89 ok

Incremental Rebuild Signal

  • Warm rebuild saved 1526.17s vs clean (676.30x faster).

This compares a clean project build against an incremental rebuild in the same CI job; it is a lightweight variability signal, not a full cross-run benchmark.

Slowest Current Clean-Build Files

Showing 20 slowest current targets, with comparison against the selected baseline when available.

Current (s) Baseline (s) Delta (s) Path
120.00 124.00 -4.00 ArkLib/Data/Polynomial/RationalFunctions/HenselNumerators/Weight.lean
86.00 95.00 -9.00 ArkLib/ProofSystem/Stir/Combine.lean
72.00 69.00 +3.00 ArkLib/Data/CodingTheory/ListDecodability/Bounds/KKH26Asymptotic.lean
65.00 77.00 -12.00 ArkLib/Data/CodingTheory/ProximityGap/CapacityBounds/UniqueDecoding.lean
62.00 66.00 -4.00 ArkLib/Data/CodingTheory/JohnsonBound/Family.lean
61.00 67.00 -6.00 ArkLib/Data/CodingTheory/SubspaceDesign.lean
59.00 71.00 -12.00 ArkLib/Data/CodingTheory/ProximityGap/DG25/MainResults.lean
57.00 61.00 -4.00 ArkLib/Data/CodingTheory/GuruswamiSudan/Basic.lean
56.00 62.00 -6.00 ArkLib/Data/CodingTheory/ProximityGap/BCIKS20/AffineLines/BWMatrix.lean
54.00 52.00 +2.00 ArkLib/Data/CodingTheory/ProximityGap/CapacityBounds/Frs.lean
54.00 45.00 +9.00 ArkLib/Data/MvPolynomial/EvenAndOdd.lean
54.00 65.00 -11.00 ArkLib/Data/CodingTheory/ProximityGap/Folding.lean
54.00 56.00 -2.00 ArkLib/Data/CodingTheory/ProximityGap/BCIKS20/AffineSpaces.lean
53.00 57.00 -4.00 ArkLib/Data/CodingTheory/ListDecodability/Bounds/LargeAlphabet/Pigeonhole.lean
49.00 73.00 -24.00 ArkLib/Data/Domain/CosetFftDomain/Subdomain.lean
47.00 51.00 -4.00 ArkLib/Data/CodingTheory/JohnsonBound/Lemmas.lean
47.00 41.00 +6.00 ArkLib/Data/CodingTheory/Connections/ListDecodingAndCA/CS25.lean
42.00 34.00 +8.00 ArkLib/Data/CodingTheory/ProximityGap/CapacityBounds/Subfield.lean
40.00 41.00 -1.00 ArkLib/Data/CodingTheory/BerlekampWelch/Condition.lean
38.00 42.00 -4.00 ArkLib/Data/CodingTheory/ProximityGap/AHIV22.lean

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

feat(coding-theory): ListLowerWitness/ListUpperWitness constructors for GrandChallenges

1 participant