# ROADMAP: from the conditional Theorem 1.1 to an unconditional one

Goal: remove the four assumed inputs of `MM.moonshine_conjecture` (listed in `README.md`,
section "Assumed") one at a time, in an order that keeps every intermediate state a *compiling* Lean
package.  Per-batch `sorry`s are allowed for the parts that are not yet proved (see the policy
bullet in "Working agreement"): `sorry`-freeness is the **completion criterion** of the whole
project, not an invariant of an intermediate state.

**How to read this file.**  It is a working document, not a narrative: the task entries carry
dated dispatcher blocks, and a dated block is **evidence, not instruction** — several are
explicitly superseded, and each says so in place.  Anything you need in order to act is in
**"Current ordering"** (near the end, just before the verification protocol) or in `README.md`
for what is proved.  The historical blocks are kept because a route that was tried and failed is
worth more than one never tried, and because three of this project's own briefs have been caught
wrong by their own arithmetic.

Working agreement
-----------------
* One task (S/T/M/A numbering below) is dispatched at a time, to one subagent.  Parallel
  work is restricted to genuinely disjoint files; the dispatcher verifies before moving on.
* Every task must end with: `tools/build.sh <its files>` (the Linux port of `tools/build.ps1`,
  same `LEAN_PATH`; see "Verification protocol" at the end) exiting 0, no `axiom`, no
  `native_decide`.  A task that does not compile is rejected.
* **Per-batch `sorry` policy (owner's standing instruction, 2026-09-22).**  A batch **may** land
  `sorry`s marking the parts that are not yet proved --- this is the sanctioned way to deliver a
  statement whose proof is still open.  Each such `sorry` must (a) be registered in the `sorry` map
  of `README.md`, and (b) be tied to the open task/residual it belongs to here or in `HANDOVER.md`;
  the declaration that consumes it must carry a `#guard_msgs in #print axioms` guard printing
  `[propext, sorryAx, Classical.choice, Quot.sound]`, so the hole is visible in the build.
  **"No `sorry` anywhere" is the criterion for the completion of the whole project** (the
  formalization of monstrous moonshine), not for a batch.
* **Build cost: take `AGENTS.md`'s figures.**  An earlier revision of this file said "~3 m 50 s for
  one module"; that is superseded (see the protocol section at the end, which also records the
  memory cap and the "do not build a file its author is still editing" rule).
* New source goes in a new file (e.g. `Definitions/MMCoxeter.lean`); existing files are
  edited only by the dispatcher.  Subagents never run `git` write commands.
* Files that a task creates should be added to the list in `FinalCheck.lean` (dispatcher).

Status legend: `[ ]` todo, `[~]` dispatched, `[x]` verified accepted, `[!]` blocked,
`[paused]` stopped by an owner decision with the reason recorded in place.

---

## Stream S — the monster group (removes assumed input 1)

The monster is **defined** here by a presentation: the `Y₄₄₃` Coxeter group modulo the spider
relation and then modulo the centre.  The Lean 3 project `formalabstracts` does the same.
Mathlib has the needed pieces: `GroupTheory/Coxeter/{Basic,Matrix,Length,Inversion}.lean`,
`Combinatorics/SimpleGraph/*`, `GroupTheory/PresentedGroup.lean`.

### Foundation: is that presentation the monster?  **Yes — it is a theorem** (settled 2026)

This was the largest risk in the project and it is now closed.  Full evidence in
`refs/README.md`; the short version:

* **Ivanov, *Y-groups via transitive extension*, J. Algebra 218 (1999) 412--435**, abstract:
  Conway conjectured (c. 1980) that the Coxeter diagram `Y555` plus the single spider relation
  `(ab₁c₁ab₂c₂ab₃c₃)¹⁰ = 1` presents the wreath product `M ≀ C₂`; **"This conjecture was proved
  by S. P. Norton and the author in 1990."**  Second treatment: Ivanov, *The Monster Group and
  Majorana Involutions*, CUP 2009.
* **Borcherds, *Problems in moonshine* (2001), Problem 5** confirms it independently and calls it
  the "Y presentation" of the monster from the ATLAS, "conjectured by Conway and Norton and
  finally proved by Ivanov ... roughly the presentation of a Coxeter group with one extra
  relation".  (Borcherds lists the *connection between the presentation and moonshine* as an open
  problem — the presentation is not in doubt, the conceptual link was.)
* **Bray's 1997 tables** record the 12-generator `Y₄₄₃` form we use (arms 4, 4, 3; 79 relators;
  same spider relation), with the remark that `Y₅₅₃` and `Y₅₄₃` present the same group.

Consequences: (a) defining the monster this way is legitimate, and the `formalabstracts`
attribution to a MathOverflow comment should not be propagated as the justification; (b) **`Y_pqr`
notation is ambiguous** — Bray: "There is more than one definition of `Y_pqr` in existence" — so
we fix our convention explicitly (arm lengths are the components of `[4,4,3]`, every bond is
labelled `3`); (c) **S3 is de-risked**: what remains is "does the presented group have order
`|M|`", no longer "is the presentation correct".

### [x] S1 — first attempt: **REJECTED**, superseded by S1b

`Definitions/MMCoxeter.lean` (321 lines, 0 `sorry`, clean build) is a correct formalization of
the **wrong diagram**: it is not the reference `Y443`.  Kept only until S1b replaces it.  Both
defects were verified against the primary source (`formalabstracts/formalabstracts`,
`src/group_theory/presentation.lean` and `src/group_theory/monster.lean`):

1. **Node count.**  `coxeter_vertices {n} (xs : dvector N+ n)` has constructors `torso` and
   `arm : ∀ x : dfin n, dfin (xs.nth'' x) → coxeter_vertices`, so the arm lengths *are* the
   components of `[4,4,3]`: `1 + 4 + 4 + 3 = 12` nodes.  `monster.lean`'s own comment agrees
   ("12 relators of the form x^2=1, one for each node").  The file has 9 nodes, arms `2,2,3`.
2. **Edge labels.**  `matrix_of_graph E x y := if x = y then 1 else if E x y then 3 else 2`
   **discards all annotations**, and `monster.lean` never calls `matrix_of_annotated_graph`.
   Hence every edge of the reference `Y443` has Coxeter number `3`; the file's
   `M 0 1 = M 0 3 = 4`, `M 0 5 = 3` is not what the reference produces.

**Correct reference data**, recomputed by the dispatcher from the source: 12 nodes; edges are
`{torso -- arm i 0}` and `{arm i v -- arm i (v+1)}` for `i < 3` and `v + 1 < (4,4,3) i`, i.e.
`3 + 3 + 3 + 2 = 11` unordered edges; the matrix has `1` on the diagonal, `3` on adjacent pairs
and `2` otherwise.  Counts: `12` ones, `22` ordered edge entries with `3`, and
`144 - 12 - 22 = 110` ordered non-adjacent pairs, i.e. `55` unordered, so
`12 + 11 + 55 = 78` Coxeter relators, exactly as the reference comment states.  (The S1-V
report's "131 ordered non-adjacent pairs" is an arithmetic slip; 78 is right.)

**API facts worth keeping from this attempt** (verified, corrected during S1b):
(1) `tauto` **times out** on a disjunctive relation at the default 200000 heartbeats — use
`rcases h with h|...|h <;> aesop`.  (2) `Matrix.of f i j` is **not** definitionally `f i j`
(`Matrix.of` is `Equiv.refl`), so `decide` cannot see through it; add a `Matrix.of_apply` bridge.
(3) `Matrix.IsSymm` is `∀ i j, A j i = A i j`, the **opposite** orientation to `A i j = A j i`;
discharge the field with `Matrix.IsSymm.ext fun i j => (entry_symm i j).symm`.
(4) **`decide` works on `Finset`/`Multiset` counts -- but only if the `Decidable` instance actually
computes.**  A `DecidableRel` written with `if h : ...` inside a dependent pattern match gets
**stuck**, and can produce an `isFalse` whose proof term does not match, so `decide` reports
*"proved that the proposition is false"* for a **true** goal; this was misdiagnosed twice (first as
a `Finset`-reduction limitation, then as a `Fin`-proof-component problem).  The fix: prove
`Edge x y ↔ (EdgeBool x y = true)` for a `Bool` function comparing `Nat`s (`v.val`, `w.val`)
rather than `Fin`s, then `DecidableRel Edge := fun x y => decidable_of_iff (EdgeBool x y = true) _`.
After that `Fintype.card = 12`, the `Finset` counts and the full `144`-entry multiset go through
with no timeout.  Remaining limitation: `Decidable (∀ i j : Fin n, ...)` has no instance, so write
`forall`-shaped facts as a filtered `Finset` count, e.g.
`(sq.filter (fun p => p.1 != p.2 && M p.1 p.2 < 2)).card = 0`.
(5) `cases h` on `h : EdgeD x x` with `x` a variable does **not** close (unification needs `x` to
be a constructor application); `cases x with | torso => ... | arm i v => ...` first.  Likewise
`rw [h, h]` on `X = X` fails after `subst`; use `(h.trans h.symm)`.

**Anti-pattern to avoid:** a "verification" theorem that does not mention the object it claims to
verify.  S1's `Y443Matrix_off_diagonal_multiset` was `9 + 4 + 14 + 54 = 81` conjoined with
`Multiset.add_assoc` -- true of every matrix, and its arithmetic was false of its own.  Any
theorem whose job is to certify a definition must have that definition's term in its statement.

### [x] S1-V — independent verification: verdict **WRONG**
* Ran as an adversarial check and reported honestly; it found both defects above and refuted
  the claimed `decide` obstruction.  Its evidence was re-verified by the dispatcher against the
  primary source before acting on it.
* Its one error: the "131 ordered non-adjacent pairs" count (should be 110, see above).

### [x] S1b — the actual `Y4 4 3` Coxeter matrix (12 nodes, every edge labelled 3) — **ACCEPTED**
* Deliverable: `Definitions/MMCoxeter.lean`, rewritten from scratch (348 lines, Mathlib only,
  0 `sorry`/`axiom`/`native_decide`).
  * `MM.Y443Arms : Fin 3 -> Nat` with `4, 4, 3`; `MM.Y443Vertex` inductive (`torso` and
    `arm i v` for `v : Fin (Y443Arms i)`) with `DecidableEq`, `Fintype`, and
    `Y443Vertex_card : Fintype.card = 12`.
  * `MM.Y443EdgeD` (the two directed `coxeter_edges_directed` constructors) and
    `MM.Y443Edge` (its symmetric closure), with `Y443Edge_symm`, `Y443Edge_irrefl`,
    `Y443EdgeD_card = 11`, `Y443Edge_card = 22`.
  * `MM.Y443Matrix : CoxeterMatrix Y443Vertex`, `1` on the diagonal, `3` on the `11` bonds, `2`
    otherwise, built with `Matrix.of` plus the `Y443Matrix_apply` bridge.
  * `MM.Y443Matrix_multiset`: the `144` entries are exactly
    `replicate 12 1 + replicate 22 3 + replicate 110 2`, **stated about `Y443Matrix.M` itself**,
    so it is non-vacuous.
  * `MM.Y443 := Y443Matrix.Group`, `Group` instance, `y443CoxeterSystem`, `y443Simple` with
    `y443Simple_mul_self`, `y443Simple_mul_simple_pow`, `y443_closure_range_simple`,
    `y443Simple_surjective`.
  * Spider generators `MM.y443A`, `MM.y443B i`, `MM.y443C i` (`i : Fin 3`) and
    `MM.y443Spider` with `y443Spider_def : y443Spider = (A * B 0 * C 0 * A * B 1 * C 1 * A * B 2 * C 2)^10`.
* Acceptance: **passed** — clean full-package build, no `sorry`/`axiom`, axioms exactly the
  three standard ones; dispatcher re-read the primary source and checked the multiset theorem's
  statement verbatim before merging.
* Verified against the reference a second time by S1b itself, independently of the brief.
* Weaker than the brief: `Y443Edge_card_half` is stated as `22 / 2 = 11`, not as a genuine
  unordered-pair cardinality (no convenient `Sym2` API was found); and the file is 348 lines
  against the ~300 guidance (one coherent unit: diagram -> matrix -> group -> generators).
* Recorded in `README.md`'s module table; merged to `main` on branch `task/s1b`.

### [x] S2 — the spider relation and `Monster` — **ACCEPTED**

* Deliverable: `Definitions/MMMonster.lean` (249 lines, 0 `sorry`/`axiom`/`native_decide`),
  wired into `FinalCheck.lean` with four guarded `#print axioms` checks.
  * `MM.y443NormalClosure := Subgroup.normalClosure ({y443Spider} : Set Y443)`, with the `Normal`
    instance — the Lean 3 `group_modulo_relations` applied to the singleton;
  * `MM.Y443Quotient := Y443 ⧸ y443NormalClosure` with `Group`, and `MM.y443Projection`;
  * `MM.monsterCenter := Subgroup.center Y443Quotient`; `MM.Monster := Y443Quotient ⧸ monsterCenter`
    with `Group`, and `MM.monsterProjection`;
  * **`MM.Monster_eq : MM.Monster = (MM.Y443Quotient ⧸ Subgroup.center MM.Y443Quotient)` is `rfl`**
    — i.e. the definition *is* the reference's, definitionally, which is exactly the kind of
    evidence wanted here;
  * `MM.monsterMk : Y443 →* Monster`, `monsterMk_apply`, `monsterMk_one`,
    `monsterMk_eq_one_iff`, `monsterMk_ker` (the kernel is
    `y443NormalClosure ⊔ monsterCenter.comap y443Projection`, via `MonoidHom.comap_ker`),
    `monsterMk_surjective`, `monsterMk_range_eq_top`, and `monsterMk_y443Spider` (the spider
    relator really is imposed);
  * a genuinely non-obvious lemma: `MM.y443Spider_mem_center` — the *image* of the spider lies in
    the centre of `Y443Quotient`, so the second quotient contributes nothing on the spider.  The
    proof is that the normal closure contains `spider⁻¹ * a⁻¹ * (spider * a)` for every `a`.
* Acceptance: **passed** — clean full-package build; no `sorry`/`axiom`; axioms exactly the three
  standard ones; dispatcher read the definitions and confirmed `Monster_eq` is `rfl`.
* **Non-triviality was attempted and correctly abandoned.**  The abelianisation argument cannot
  work, and the agent computed *why* rather than asserting it: the spider has word length
  `9 * 10 = 90` with each factor of order 2, so its image in the abelianisation
  `∏ᵥ ZMod 2` is `1 ^ 90 = 0`, i.e. the spider lies in the kernel of the abelianisation, which
  therefore does not descend to `Y443 ⧸ ⟪spider⟫`.  More fundamentally, the monster is perfect,
  so **every** abelian quotient is trivial and no abelian argument can ever detect
  non-triviality.  This is recorded in the file's `Nontriviality` section.  Consequence: `S3`
  is the only route to non-triviality, finiteness, and the order.
* Honest status of "does the reference definition give the monster": the definition matches the
  reference *definitionally*; the theorem that the reference presents `M × C₂` is
  **Norton–Ivanov 1990** (`refs/README.md`) and is **not** formalized here.  So the remaining
  gap is a named, cited theorem, not an unexamined assumption.

**Independent verification (S2-V): verdict `CONFIRMED`.**  A separate agent checked every link
against the Lean 3 source and by compiling its own probes: `y443NormalClosure` is the normal
closure of the *singleton* (proved minimal, contains all conjugates, so it agrees with Lean 3's
`closure (conjugates s)` — though no Mathlib lemma identifies the two definitions, the agreement
is semantic); `monsterCenter` is `Subgroup.center` of *that* quotient; `Monster_eq` is `rfl`.
Two findings were acted on, see the commit:

* **`monsterMk_ker` was true but uninformative.**  The join `⟪spider⟫ ⊔ center.comap mk` is the
  *whole group*, because the projection is surjective so the second summand is already `⊤`.  The
  theorem is now stated in the informative form `monsterMk.ker = center.comap mk`, matching what
  the proof derives internally.
* **The non-triviality paragraph was duplicated and gave a weak reason.**  Rewritten: the
  obstruction is structural (every relation `(sᵢsⱼ)^m = 1` is a word of length `2m`, hence `1` in
  any abelian quotient; the abelianisation of `Y443` is `ZMod 2`, not a product of twelve copies,
  because `m = 3` is odd forces all generators to the same image; the spider has length `9·10`.
  The two arithmetic lemmas are now labelled as bookkeeping, and building the actual map
  `Y443 →* Multiplicative (ZMod 2)` via `Abelianization.lift` is recorded as a refinement.

**Correction to the S2-V report itself:** it claimed the parity argument was wrong and that the
abelianisation is `∏ᵥ ZMod 2`.  Both are incorrect — in an abelian quotient `(sᵢsⱼ)^m = 1` with
`m ≥ 2` forces `sᵢsⱼ = sⱼsᵢ`, and with `m` odd it forces `sᵢ = sⱼ`.  The verifier's alternative
("the spider lies in the commutator subgroup, every abelian quotient kills it") is also true and
is now recorded alongside; it is the same phenomenon.

**Mathlib API facts found here — worth not rediscovering** (all verified):

| need | exact name |
| --- | --- |
| normal closure | `Subgroup.normalClosure : Set G → Subgroup G`; instance `Subgroup.normalClosure_normal` |
| quotient type / map | `G ⧸ N`; `QuotientGroup.mk' N : G →* G ⧸ N`, `QuotientGroup.mk'_apply` |
| centre | `Subgroup.center G`; normality is **`Subgroup.instNormalCenter`** (there is no `center_normal`); membership `Subgroup.mem_center_iff` |
| kernel | `MonoidHom.ker`, `MonoidHom.mem_ker` (use `.mp`; do **not** write `(MonoidHom.mem_ker f).mp`) |
| kernel of a composite | **there is no `MonoidHom.ker_comp`**; use `MonoidHom.comap_ker g f : (g.comp f).ker = g.ker.comap f` |
| kernel of a quotient map | `QuotientGroup.ker_mk' N : (QuotientGroup.mk' N).ker = N` |
| equality in a quotient | `QuotientGroup.eq_one_iff`, `QuotientGroup.eq`, or `Quotient.sound ∘ QuotientGroup.leftRel_apply.mpr`; prefer the last, because `rw [QuotientGroup.eq]` fails when the goal prints as `↑a * ↑s = ↑s * ↑a` rather than `↑(a*s) = ↑(s*a)` |
| conjugation-closed | **`Subgroup.Normal.conj_mem' n hn g : g⁻¹ * n * g ∈ N`** — counter-intuitive argument order (third argument is the conjugated element, fourth the conjugator) and it produces `g⁻¹ * n * g`, not `g * n * g⁻¹` |
| comap of top | `Subgroup.comap_top f : (⊤ : Subgroup N).comap f = ⊤` (not `comap_id`) |
| induction on a quotient | `QuotientGroup.induction_on`, branch syntax `| _ a => ...` |

### [ ] S3 — `Monster` is finite, of the known order
* Deliverable: `Finite MM.Monster` and/or `Nat.card MM.Monster = 808017424794512875886459904961710757005754368000000000`.
* Acceptance: builds, no `sorry`.
* Risk: **very high**.  Lean 3 did not prove this.  The realistic route is a permutation
  representation (the monster acts on 196884 points of the Griess algebra) or the
  `2²⁴·Co₁` route; either is a project of its own.  If this task proves intractable, the
  fallback is to keep `Finite` as a *hypothesis* in `MoonshineModule` and record it here.

> **S3-RECON LANDED (task agent, dispatcher-reviewed 2026-09): NONE of the three "real" routes is
> dispatchable, and the reason is structural rather than a matter of effort.**  `Finite MM.Monster` is
> not a statement about a concrete group but about a **presentation**: `MM.Monster` is
> `Y443 ⧸ ⟪spider⟫ ⧸ center` (`Definitions/MMMonster.lean`).  Every Mathlib mechanism for `Finite X`
> with `X` presented is a `MulEquiv` with a known finite type, an injection into one, or a surjection
> out of one — there is **no Todd--Coxeter, no coset enumeration, no rewriting engine, and no
> finiteness theorem about any presented group except the trivial "finite ⟹ finitely presented"**
> (`FinitelyPresentedGroup.lean:176`) — and any upper bound for `Nat.card MM.Y443Quotient` is verbatim
> a normal-form certificate for the 12-generator presentation of `M × C₂`, with `2·|M| ≈ 1.6 × 10^54`
> entries.  **So S3's *first* half is already the hard half.**  Route (c) ("finiteness and the order
> from the presentation via Seysen") does not exist: neither Seysen paper proves anything from a
> presentation — they implement a *given* representation.  Route (b) is a strict sub-part of (a), and
> (a) — the only route that has ever worked mathematically — would still not prove `Finite
> MM.Monster`, for the reason above.
>
> **Correction of record: the 51-digit order literal that circulated in the dispatching brief is
> wrong; the 54-digit literal in this entry's own Deliverable line above is right** — verified here by
> recomputing the product (`2^46·3^20·5^9·7^6·11^2·13^3·17·19·23·29·31·41·47·59·71`), whose value
> equals the Deliverable literal and is `1000 ×` the brief's.  No file in the repository carries the
> wrong literal (checked by search over `ROADMAP.md`, `README.md`, `Challenge.lean`,
> `Definitions/MMMonsterMoonshine.lean`, `FinalCheck.lean`).  A Lean statement with the brief's numeral
> would be a false statement about `MM.Monster`.
>
> **Recommendation, and the dispatchable first increment (S3-D).**  Take the recorded fallback (d),
> but *sharpened*: make the missing input a named, non-vacuous declaration with proved conditional
> consequences, and attempt none of (a)/(b)/(c) as a route to finiteness or the order.  The brief is
> new file `Definitions/MMMonsterOrder.lean` (≈150--250 lines, one agent-run, low risk): (1)
> `Finite MM.Y443Quotient → Finite MM.Monster` (the quotient map is surjective); (2) under that
> hypothesis, `Nat.card MM.Monster = MM.monsterCenter.index`; (3) a named
> `MM.NortonIvanovPresentation : Prop` — `Nonempty (MM.Y443Quotient ≃* (MM.Monster × Multiplicative
> (ZMod 2)))` — whose docstring says that this is Norton--Ivanov 1990, that it is **not** proved here,
> that its only known proof is a coset enumeration, and that it is the only missing input for
> finiteness; (4) its conditional consequences, including explicitly that it does **not** give the
> order; (5) a scope section saying that no finiteness, order or non-triviality of `MM.Monster` is
> proved and that the order is a third, independent input.  The full report, with the per-route
> pricing, the verified Mathlib inventory (`path:line`) and the literature (Seysen ×2, Aschbacher, the
> ATLAS) is `Probe/S3_RECON.md` (gitignored — this block is its committed substance).
>
> **S3-D LANDED, dispatcher-verified (2026-09): the fallback is now declarations, not prose.**
> `Definitions/MMMonsterOrder.lean` (244 lines, 20 declarations, guarded in `FinalCheck.lean`)
> proves the **free** direction — `MM.finite_monster_of_finite_y443Quotient : Finite MM.Y443Quotient →
> Finite MM.Monster` — the index formula for the centre (`MM.card_monster_eq_monsterCenter_index`,
> `MM.card_monster_mul_card_monsterCenter`) and, **with** the identification, that the centre *is*
> the `C₂` (`MM.card_monsterCenter_eq_two_of_nortonIvanov`).  It names the two inputs as `Prop`s
> (`MM.Y443QuotientFinite`, `MM.NortonIvanovPresentation`, quoted from Ivanov's abstract as
> `refs/README.md` has it) and a third for the order (`MM.MonsterOrder`), and it settles the order's
> arithmetic in Lean: the **54-digit** numeral `MM.monsterOrder`, its prime-power factorization, its
> digit count, and `MM.monsterOrder_ne_wrongLiteral` — **the 51-digit literal that circulated in this
> dispatcher's brief is now refuted by a theorem.**  **The task caught a real error in its own
> brief:** `NortonIvanovPresentation → Finite MM.Monster` is *not provable* (an isomorphism with
> `M × C₂` bounds neither side), so the finiteness engine is `Y443QuotientFinite` and the delivered
> theorem carries it explicitly — nothing was weakened.  Dispatcher-verified from source: `--- OK ---`
> for `MMCoxeter`, `MMMonster`, `MMMonsterOrder` and an independent axiom probe,
> `forbidden_tokens` 0/0/0/0, every guarded declaration on `[propext, Classical.choice, Quot.sound]`
> (two arithmetic ones on `[propext]` alone), and `FinalCheck.lean` green with the new guards.
> **What is missing is unchanged and is the hard part:** the finiteness of the presented quotient,
> and then its order.

### [x] S4 — retarget `MoonshineModule` to `MM.Monster` — **ACCEPTED (S4 + S4b, this session)**
* Deliverable: `MoonshineModule.G` instantiated at `MM.Monster`, so that
  `MM.moonshine_conjecture` becomes a statement about the Fischer--Griess monster.
* Depends on S2 (S3 optional).
* **PROGRESS (this session).**  `Definitions/MMMonsterMoonshine.lean` (207 lines) supplies
  `MM.MoonshineModule.IsMonsterModule M := Nonempty (M.G ≃* MM.Monster)`,
  `MM.MoonshineModule.MoonshineConjectureStatementMonster` (the headline with that conjunct),
  proved reductions to `MoonshineConjectureStatementGenus` and to the pre-D0-g statement, and — as
  real content rather than plumbing — **`MM.MoonshineModule.reindex`**, which transports a whole
  `MoonshineModule` along a group isomorphism (graded pieces, actions, traces, `replication` via
  `map_pow`), so that `isMonsterModule_reindex` makes the monster property a property of the
  **isomorphism class** and the statement is not an artefact of a presentation.
  **What is NOT bought, and is recorded in the file:** no finiteness, order or non-triviality of
  `MM.Monster` (that is **S3**), no formalized identification with Griess's construction (the cited
  Norton--Ivanov theorem), and no inhabitant — `IsMonsterModule` is not known satisfiable because no
  `MoonshineModule` is known at all.
  **THE RE-POINT IS DONE (task S4b).**  `IsMonsterModule` and `MoonshineConjectureStatementMonster`
  moved into `MMMoonshine.lean` (which now imports `Definitions.MMMonster`, verified acyclic), so the
  standing goal is
  `MM.MoonshineModule.moonshine_conjecture : MoonshineConjectureStatementMonster := by sorry`
  — the repository's one open-problem `sorry` now names `MM.Monster`.  `Challenge.lean` follows, and
  `MMGenusZeroStatement.lean` / `MMLevelOneGenusZero.lean` had docstrings that had just become false
  and were corrected.  The proved chain is monster ⟹ genus ⟹ pre-repair, and each level has a
  non-vacuity theorem.  **Still not bought:** finiteness/order (S3) and the cited Norton--Ivanov
  identification.

---

## Stream T — the monster Lie algebra and (8.3) (removes assumed input 3)

### [x] T1 — formal power series infrastructure for (8.3) — **PARTIAL, merged**

The scope of T1 turned out to be three things, not one: the infrastructure (done), a Mathlib gap
(found and named), and the Möbius inversion (deferred to T2).  Recorded accordingly.

* Deliverable: `Definitions/MMPowerSeries.lean` (170 lines, 19 declarations, 0 `sorry`/`axiom`).
  **Design decision, now settled:** the paper's two-variable series live in
  `PowerSeries (HahnSeries ℤ ℚ)` — power series in `p` whose coefficients are formal Laurent
  series in `q`.  `MvPowerSeries.exp` does not exist in Mathlib, whereas `PowerSeries.exp`/`log`
  need only `[CommRing A] [Algebra ℚ A]`, which this ring has; and the convergence structure is
  right (each `p`-degree is affected by only finitely many factors).
  * `MM.EulerSeries` and `MM.adamsLog`: verbatim the paper's `E = Σ_{m>0,n∈ℤ} c(g,mn) pᵐ qⁿ` and
    `L = Σ_{i>0} Σ_{m>0,n∈ℤ} c(g^i,mn) p^{mi} q^{ni}/i`, the `i`-th term of `L` being the Adams
    operation `ψⁱ`.
  * `MM.monomial`, `coeff_monomial`, `MM.qCoeffOfBounded` with `qCoeffOfBounded_mono`
    (independence of the truncation bound).  The bound is an explicit parameter rather than
    extracted by `Classical.choice` from the finiteness hypothesis — cleaner, and it means every
    downstream statement carries a bound until a bound-extraction lemma is available.
  * `MM.seriesIdentity_of_adamsLogIsLog`: the paper's exponential form `exp L = 1 + E`, derived
    from the two named hypotheses below.
  * Non-vacuity: `eulerSeries_zero`, `adamsLog_zero`, `adamsLogIsLog_zero`.
* **Not proved, stated as named `Prop`s rather than asserted** (this is the honest record):
  * `MM.ExpLogOf (f) : expOp (logOf f) = f` — **a genuine Mathlib gap.**  In this revision
    `PowerSeries/Exp.lean` and `Log.lean` provide `exp_unique_of_derivative_eq_self`,
    `derivative_exp`, `deriv_log`, `logOf_eq`, `logOf_one_add_X`, `HasSubst.log`,
    `HasSubst.exp_sub_one`, `derivative_subst` — but **nothing composes `exp` with `logOf`**.
    The missing ingredient is a chain rule for `PowerSeries.subst` at `log` (or at `exp - 1`),
    i.e. `derivative (subst g f) = subst g (derivative f) * derivative g`, usable at `g = log`;
    `derivative_subst` exists precisely for that purpose and is not yet applied to `log`.
    Dispatcher note: the route is `exp_unique_of_derivative_eq_self` on `expOp (logOf f)`, whose
    derivative is `expOp (logOf f) * (derivative f / f)`; the first factor is the inductive
    hypothesis and the second is `f' / f`, so the identity follows once the chain rule is in
    place.  The `f` must have `constantCoeff f = 1`, and the target is to state it in
    `PowerSeries A` for `A` a `ℚ`-algebra (our use is `A = HahnSeries ℤ ℚ`).
  * `MM.AdamsLogIsLog (c) (g) (bound) : adamsLog c g bound = logOf (1 + EulerSeries c g bound)`
    — **this is the Möbius inversion (10.3) ⇒ (10.4)**, i.e. T2's target.
  * The root-multiplicity formula (10.4) with `ArithmeticFunction.moebius`, and the recursion
    (9.1): **not attempted** (reported as such rather than half-done).
* Acceptance: build exits 0 for all modules; no `sorry`/`axiom`/`native_decide`; axioms exactly
  the three standard ones.
* Note for the next agent: `PowerSeries.exp` is an **element**, not a function, in this Mathlib
  revision; `MM.expOp` wraps it.
* **Next task becomes `T1b` (below), not T2**: the cheap half of T2 is the Mathlib gap.

### [x] T1b — the composition law `exp ∘ logOf f = f` — **ACCEPTED**

> **CLOSED.**  `Definitions/MMExpLog.lean` now proves the theorem the task asked for:
> `MM.expOp_logOf_eq (f) (hf : PowerSeries.constantCoeff f = 1) : expOp (PowerSeries.logOf f) = f`,
> with the uniqueness step it rests on, `MM.eq_zero_of_derivative_eq_mul (hd : derivative h = h * L')
> (hc : constantCoeff h = 0) : h = 0`, and the two consequences that wire it into
> `Definitions/MMPowerSeries.lean`: `MM.expOp_logOf_holds` and
> `MM.seriesIdentity_of_adamsLogIsLog`.  Build exits 0; all four new declarations are guarded in
> `FinalCheck.lean` and print exactly `[propext, Classical.choice, Quot.sound]`.
>
> **Two corrections to the plan recorded below, both verified by compiling.**
> 1. **The uniqueness lemma needs NO hypothesis on `L'`.**  The plan's `constantCoeff L' = 1` is not
>    merely unused, it is **false** at the intended instantiation `L' = (logOf f)'`:
>    `constantCoeff ((logOf f)') = coeff 1 f`, which is `2` for `f = 1 + 2X`.  A lemma stated with
>    that binder could never have been applied.  The induction needs only that `n + 1` is not a zero
>    divisor (`MM.instIsAddTorsionFreeHahnSeries`); even `L' = 0` is allowed.  The task's own
>    justification ("valid because `L'` is a unit with constant coefficient `1`") was wrong about
>    *why*.
> 2. **The last step is one subtraction, not the `f⁻¹` route.**  The plan's steps 4--7 (product rule,
>    `PowerSeries.derivative_inv'`, `(S * f⁻¹)' = 0`) are unnecessary: `h := S - f` already has
>    `h' = h * L'` and `constantCoeff h = 0`, so `S = f` directly.  No inverse, no unit argument.
>
> **API fact worth keeping** (it cost a probe round): in this Mathlib pin `Finset.antidiagonal` is
> the `Set.IsPWO` version, so `Finset.mem_antidiagonal` has the wrong type for the ℕ-antidiagonal
> that `PowerSeries.coeff_mul` produces.  The right names are
> **`Finset.HasAntidiagonal.antidiagonal`** and **`Finset.HasAntidiagonal.mem_antidiagonal`**, and
> `omega` then reads the membership directly (`p.1 ≤ n`).  Likewise `Nat.cast_succ` +
> `nsmul_right_inj (Nat.succ_ne_zero n)` is the working idiom for cancelling `(n + 1)` over
> `HahnSeries` -- there is **no** synthesizable `CharZero (HahnSeries ℤ ℚ)`.
>
> **New finding, and it changes how T2 is wired (flagged for T2, not resolved here).**
> `MM.constantCoeff (1 + EulerSeries c g bound) ≠ 1` whenever `c g 0 ≠ 0` -- the `p^0` coefficient of
> `EulerSeries` is `Σ_{1 ≤ m ≤ bound} c(g,0) q^m`, non-zero for the monster, where `c(g,0) = 1`.  So
> `expOp_logOf_eq` **cannot** be applied to `1 + EulerSeries c g bound` without a constant-term
> hypothesis, and `MM.seriesIdentity_of_adamsLogIsLog` now carries that hypothesis explicitly.  The
> paper's series carries the `p⁻¹` prefactor of (8.3), which is what removes the term.  Verified by
> compiling, not merely asserted.

**Delivered and guarded** (T1b's own scaffold; the file has since grown to carry the closure above):

| declaration | statement |
| --- | --- |
| `MM.deriv_log_eq_inv` | `(log A)' = (1 + X)⁻¹` over `A = HahnSeries ℤ ℚ`, from `MMGeomSeries` |
| `MM.subst_inv_one_add_X` | `subst (f - 1) ((1+X)⁻¹) = f⁻¹` |
| `MM.derivative_logOf_mul` | **`(logOf f)' * f = f'`** — the identity that drives the route |
| `MM.constantCoeff_expOp_logOf` | `constantCoeff (subst (logOf f) (exp A)) = 1` |
| `MM.derivative_eq_mul_derivative_logOf` | `f' = f * (logOf f)'` |

plus the previously landed `HasSubst` facts and `MM.instIsAddTorsionFreeHahnSeries`, and
`Definitions/MMGeomSeries.lean` (committed as `c728014`) with the geometric series.

#### Earlier history of this entry (kept: each revision was wrong in an instructive way)

This entry has been rewritten twice, and the previous two readings were **both wrong**.  **Read all of
it before dispatching; the two failure modes recorded here cost two full rounds.**

**Attempt 1 (agent, no file modified)** corrected the map but left the task believed to be "a few
hours, bookkeeping".  Its one durable contribution was closing the instance gap (Correction 2 below).
Its failure mode was "probe for a guessed lemma name instead of reading the file".

**Attempt 2 (agent) killed the substitution route outright.**  The results, re-verified by the
dispatcher:

1. **`Probe/Probe.lean` does not compile** — `tools/build.ps1 Probe/Probe.lean` exits 1 with
   three errors (`24:6` a failed `rw` pattern, `28:79` where `MvPowerSeries.C 1 = PowerSeries.C 1`
   is not `rfl`, `40:4` where `subst_comp_subst_apply` wants `HasSubst (exp A)` and is handed
   `HasSubst (exp A - 1)`); its `h1` step `subst (exp A - 1) f = f - 1` is **false** (at
   `f = 1 + X`: left `exp A`, right `X`).  Attempt 1 had recorded this probe as a "compiling
   witness"; it had never been compiled.  **A scratch file that "must compile" is not evidence until
   it has been compiled.**
2. **The substitution route is circular, not bookkeeping.**  `subst_comp_subst_apply`
   (`Substitution.lean:391`) is functoriality of `subst a : p ↦ p(a)`; it rewrites one composite
   substitution into another and can never identify a composite with a given series (at `p = X` it
   degenerates to `subst a b = subst a b`).  The three identities the route needs —
   `subst (log A) (exp A - 1) = X`, `subst (exp A - 1) (log A) = X`, `subst (log A) (exp A) = 1 + X`
   — are each **equivalent to `exp (log (1+X)) = 1+X`**, i.e. to the statement being proved.

**Correction 2 stands, and is delivered.**  `IsAddTorsionFree (HahnSeries ℤ ℚ)` is not synthesizable,
and `PowerSeries.exp_unique_of_derivative_eq_self` demands it; the instance is now
`MM.instIsAddTorsionFreeHahnSeries` in `Definitions/MMExpLog.lean`, with the `HasSubst` facts
(`MM.hasSubst_logOf`, `MM.hasSubst_sub_one`), `MM.expOp_eq_subst_comp` and
`MM.hasSubst_logOf_one_add_X`.

**Not delivered at that round:** `MM.expOp_logOf` / `MM.ExpLogOf` as theorems — they were the
`Prop`-valued definitions of `MMPowerSeries.lean:193,218`, and **exactly one step was missing**: with
`h := subst (logOf f) (exp A) - f` and `L := logOf f`, the product rules give `h' = h * L'` and
`constantCoeff h = 0`, and what was needed was `h' = h * L' → constantCoeff h = 0 → h = 0` —
uniqueness for a first-order linear equation over `A`, by induction on the coefficient using
`coeff n (h * L') = coeff (n+1) h * (n+1)`.  `PowerSeries.derivative.ext` does **not** give this
(it needs `h * L' = 0`, which is the conclusion); **short-circuiting it produces a self-referential
proof that Lean rejects** (`fail to show termination`) — that is how the gap was found.

**Three dead ends, recorded so they are not re-entered:** (1) the substitution route is circular
(above); (2) `subst (logOf f) (exp A) = exp A` is **false** — `subst` is composition, so it says
`exp ∘ logOf f = exp`, and `logOf f ≠ X`; (3) the constant coefficient does **not** come from
`PowerSeries.constantCoeff_subst`, whose `finsum` collides with the `MvPowerSeries`/`PowerSeries`
namespace split — `MM.constantCoeff_expOp_logOf` splits `exp A = 1 + (exp A - 1)` instead.

**The live route that closed it: derivative.**  With `S := subst (logOf f) (exp A)`,
`hf : constantCoeff f = 1`, and `A = HahnSeries ℤ ℚ`:

1. `(f - 1)' = f'`.
2. `(logOf f)' = ((log A)').subst (f - 1) * (f - 1)'` by `PowerSeries.derivative_subst`
   (`Derivative.lean:140`) at `g = f - 1`, using `HasSubst (f - 1)` from `hasSubst_sub_one`.
3. **The one substantive identity: `f' = f * (logOf f)'`.**  `PowerSeries.deriv_log`
   (`Log.lean:67`) gives `(log A)' = mk fun n ↦ algebraMap ℚ A ((-1)^n)`, so this needs the
   geometric-series identity `mk (fun n ↦ ((-1 : ℚ) ^ n : A)) * (1 + X) = 1`, i.e.
   `(log A)' = (1+X)⁻¹`, and then that `subst` carries inverses:
   `((1+X)⁻¹).subst (f - 1) = ((1+X).subst (f - 1))⁻¹ = f⁻¹`, the last step by
   `(1+X).subst (f - 1) = 1 + (f - 1) = f`.  **The geometric-series identity comes first: it is
   independent, it is real work, and everything else depends on it.**
4. `S' = S * (logOf f)'` by `derivative_subst` at `g = logOf f`.
5. Hence `(S * f⁻¹)' = 0` (product rule plus `PowerSeries.derivative_inv`, `Derivative.lean:117`;
   `f` is a unit since `HahnSeries ℤ ℚ` is a field and `constantCoeff f = 1`).
6. `S * f⁻¹ = 1` from step 5, `constantCoeff (S * f⁻¹) = 1`, and `PowerSeries.derivative.ext`
   (`Derivative.lean:112`, needs `[IsAddTorsionFree R]`) — or by `PowerSeries.coeff_derivative`
   (`Derivative.lean:60`), which gives `coeff (n+1) = 0` for all `n` directly.
7. `S = S * f⁻¹ * f = f`.

**Four "obstructions" recorded by attempt 2 are mostly false** (attempt 3 measured each):
(a) `Finset.sum_eq_single` *does* match the `antidiagonal` binder notation — Mathlib itself writes
`rw [coeff_mul, Finset.sum_eq_single (d, n), ...]` at `RingTheory/PowerSeries/Basic.lean:347`; the
real trap is that `rw [sum_eq_single a]` emits its subgoals in the order "`a ∉ s` first, main
equality second", the opposite of `apply`; (b) pair projections do **not** need `show` —
`norm_num`/`ring` handle them; (c) `set_option maxHeartbeats 800000` is **not** needed, the default
200000 suffices.  Only the fourth (using `eq_inv_iff_mul_eq_one`, `Inverse.lean:178`, not the
reversed `inv_eq_iff_mul_eq_one`) survived.  **A reported blocker is a hypothesis too.**

**The winning tactic is a change of ring, not new mathematics.**  Working directly over
`A = HahnSeries ℤ ℚ` puts an `algebraMap ℚ A` in every coefficient and `ring` cannot close the
arithmetic; working over `ℚ` makes the coefficients plain rationals and `ring`/`norm_num` finish,
after which `PowerSeries.map` pushes the result to `A`.

> **CORRECTION (attempt 4, verified by the dispatcher).**  Attempt 3 reported that
> `Probe/Geom4.lean` "compiled" `altQ`, `coeff_one_add_X`, `mem_one`, `mem_zero`,
> `sum_eq_two_terms` and `third_pair_zero`.  **It did not compile at all.**  The dispatcher
> reproduced it: `lean` on `Geom4.lean` exits non-zero at line 44 (`rw` cannot find its pattern in
> `F (1, n) = F (1, n) + F (0, n+1)`), and `build/lib/lean/Probe/` contained no `.olean` for it.
> **The dispatcher then repeated the mistake by putting "Geom4 already compiles" into the attempt-4
> brief without verifying it — the third occurrence of this failure mode in this task, and the one
> that cost a whole round.**  Do not treat any `Probe/` file as a starting point unless you have
> just compiled it yourself.
>
> What attempt 4 *did* establish, by its own `#eval`: `coeff j (1+X)` is `[1, 1, 0, 0, 0]` for
> `j < 5`, and the two-term sum `(-1)^m·[X^m](1+X) + (-1)^(m+1)·[X^(m+1)](1+X)` vanishes for every
> `m` — identically zero, not merely for `m ≥ 2`.  It compiled `coeff_altQ`, `coeff_altQ_zero`,
> `coeff_altQ_one`, `coeff_one_add_X_zero/one/of_two_le`, `summand_eq_zero_of_two_le`, both
> elimination branches of `sum_eq_two`, and both `m`-branch arithmetics.  **Not obtained:**
> `altQ * (1 + X) = 1`.
>
> Two residuals, both `Finset` bookkeeping rather than mathematics: `Finset.sum_eq_single` leaves a
> **membership side goal** that `rw [Finset.mem_antidiagonal]` cannot discharge (the goal mentions
> `Finset.HasAntidiagonal.antidiagonal`), and `PowerSeries.coeff_one` produces its condition in
> **`m.succ` form**, so `if_neg` on an `m + 1`-shaped hypothesis does not fire.  Also measured: `rw`
> with an elaboration-bearing argument (`rw [lemma (by tac)]`) produces spurious `⊢ False` goals
> inside a longer chain — use `have h := lemma (by omega)` then `rw [h]`; and `Prod.ext` takes `fst`
> first.  **Attempt 5's route avoids `antidiagonal` altogether**: split `altQ * (1+X) = altQ + altQ * X`
> and use `PowerSeries.coeff_mul_X_pow` (`Basic.lean:345`), which sends `coeff (m+1) (altQ * X)` to
> `coeff m altQ`, leaving the pure arithmetic `(-1)^(m+1) + (-1)^m = 0`.
>
> **Meta-lesson, now in `AGENTS.md`:** an uncompiled file is not evidence, and neither is a
> dispatcher's summary of one.

**Attempt 3's own error, located:** in `altQ_mul_one_add_X` it negated the coefficients of
`[X^m](1+X)` and `[X^(m+1)](1+X)`.  The correct values are `m = 0 → 1`, `m = 1 → 1`, `m ≥ 2 → 0`
for the first, and `m = 0 → 1`, `m ≥ 1 → 0` for the second; hence the `m = 1` leaf goal is
`(-1)*1 + 1*0 = 0`, which is true, where attempt 3 wrote `(-1)*1 + 1*1 = 0`, which is false.  That
false leaf — not the tactics — is why its `norm_num`/`ring` finishes kept failing.  The fix is to
discharge the three `if`s (`m = 0`, `m + 1 = 0`, `m + 1 = 1`) with `if_neg` separately before `ring`.

**On the `IsAddTorsionFree` instance — attempt 3's closing recommendation is wrong and must not be
acted on.**  It reported that `MM.instIsAddTorsionFreeHahnSeries` is not needed because
`derivative.ext` needs `[IsAddTorsionFree R]` and `ℚ` is not torsion-free.  The premise is right
(`IsAddTorsionFree` is `to_additive` of `IsMulTorsionFree`, `Algebra/Group/Defs.lean:787`; indeed
`2 • (1/2) = 1 = 2 • 0` in `ℚ`), but the conclusion is backwards: our series live in
`PowerSeries (HahnSeries ℤ ℚ)`, so the `R` in `derivative.ext` **is** `HahnSeries ℤ ℚ`.  It is
**required**, not decorative, and cannot be synthesised.  The alternative it offered (induct on `n`
via `PowerSeries.coeff_derivative`) is a legitimate fallback but is *additional* work.

**Kept from the previous revision, for the record only — this is NOT the route:**
`subst_comp_subst_apply` was claimed to be "the composition law the proof needs" and the two lemmas
below were claimed to suffice via substitution.  Point 2 above refutes that.  The lemmas themselves
are still true statements and are *consequences* of the derivative route, not inputs to it:

```lean
theorem derivative_logOf {f : A⟦X⟧} (hf : constantCoeff f = 1) :
    (d⁄dX A) (PowerSeries.logOf f) * f = (d⁄dX A) f

theorem expOp_logOf (f : A⟦X⟧) (hf : constantCoeff f = 1) :
    expOp (PowerSeries.logOf f) = f
```

* Acceptance: build exits 0; no `sorry`/`axiom`/`native_decide`; axioms the three standard ones;
  and `MM.expOp_logOf`'s theorem statement must agree verbatim with the `Prop` it replaces.
* Risk: **medium-high, not low-medium.**  This is genuine proof work (a geometric series identity,
  substitution of inverses, and a derivative-zero argument), not bookkeeping.  The map above is
  verified at the level of lemma names and signatures; the remaining risk was in steps 3 and 5.

### [~] T2 — the denominator identity (8.3): sections 6--8 (unproved), plus its self-contained §10 half (T2a, `Prop` unproved) — **the apparent (8.3)-vs-(10.1) conflict was a verifier artefact and is closed**

> **T2a CLOSED — the alarm was a VERIFIER ARTEFACT.  The paper's (8.3) and (10.1) AGREE, and the
> repository's `MM.DenominatorIdentity` is a faithful transcription of (8.3).**
>
> Task T2-VERIFY's self-checking exact-arithmetic program (`Probe/t2_verify_result.py`; the fuller
> `Probe/t2_verify.py` carries more self-checks) compares the divisor arithmetic of the two
> printed identities — `[p^a q^b] log PROD = −Σ_{k|gcd(a,b)} mult(a/k,b/k)/k` against
> `[p^a q^b](−L) = −Σ_{i|gcd(a,b)} c(ab/i²)/i` — with no series normalisation anywhere, and reports
> **agreement on all 36 coefficients with `1 ≤ a,b ≤ 6`**: `[p¹q¹] = −196884`,
> `[p²q¹] = −21493760`, `[p²q²] = −20245954698`, `[p³q³] = −65628`.
>
> **A dispatcher error, found by that task and re-verified independently.**  Both the dispatching
> brief and an earlier revision of this entry expected `mult(2,1) = c(2) + c(1)/2 = 21592202`.  That
> is **wrong**: `gcd(2,1) = 1`, so (2.3) has the single term `(d,s) = (1,1)` and
> `mult(2,1) = c(2) = 21493760`.  The value `21592202` mis-sums `ds | m` instead of `ds | gcd(m,n)`,
> the substitution the paper defines in the sentence after (2.3).  Checked by direct implementation:
> `mult(1,1) = c(1)`, `mult(2,1) = c(2)`, `mult(2,2) = c(4)`, `mult(1,−1) = 1` (`V_{−1} = 1`).
> **A wrong expectation in a brief is how a correct formula comes to look broken.**
>
> **Why there were seven unstable runs, in one sentence:** both sides equal
> `P := p·(T_g(p) − T_g(q))` (the `p` matters: (2.1)/(2.2) carry `p⁻¹` on the left), and `P`'s `p⁰`
> block is `−q⁻¹ + Σ c(n)qⁿ`, a **unit** in the `q`-Laurent ring, so comparing `p`-blocks of `log P`
> requires dividing by that `p`-free factor first.  Every shortcut tried — `log(1+(P−1))` (invalid:
> `P` is not `1 + O(p)`), multiplying all blocks by `−q`, forgetting to drop the `p`-free remainder —
> produced a spurious mismatch of exactly `c(1)²`.  The verifier was the problem, not the paper.
>
> **What was actually open in stream T, unchanged and ordinary:** `MM.DenominatorIdentity` is a
> faithful transcription of (8.3) that is **unproved** (task T2 proper, the paper's §6--8), and
> T2a's `(10.4)` was then an unproved `Prop` in the untracked `Definitions/MMRootMultiplicity.lean`.
>
> **One finding that stands, and it is a design question rather than a defect:**
> `MM.EulerSeries`'s `q`-side is one-sided (positive powers) while the paper's sum runs over `n ∈ ℤ`;
> `MM.adamsLog` is faithful — its `q ↦ q^i` substitution is the third argument of `MM.qCoeffOf`, and
> a later agent's report that the `ψ^i` substitution was missing is **false**, settled by the code at
> `MMPowerSeries.lean:112` and `:160`.  Whether to re-express either definition over the two-sided
> ring is the owner's call; the `p`-multiplied `MM.DenominatorIdentity` works around the one-sidedness.
>
> **Two dispatcher errors are on record, both caught by verification rather than by reading:** the
> false `c(1)²` alarm, and the false `mult(2,1)` expectation.  The corollary this entry adds to
> `AGENTS.md`'s *a reported blocker is a hypothesis* is that **the dispatcher's own brief and its own
> arithmetic are hypotheses too**.

> **T2a IS PROVED AND ACCEPTED (2026-09-13).**  `Definitions/MMRootMultiplicity.lean` (261 lines) +
> `Definitions/MMRootMultiplicityArith.lean` (201 lines), both in `FinalCheck.lean` with six
> `#print axioms` guards: **`MM.moebiusSum_adamsSum : 0 < k → moebiusSum (adamsSum B) k = B k`** is
> the Möbius inversion of the `p`-grading — `adamsSum B k = Σ_{i|k} B(k/i)/i` is the `p^k`-block of
> (10.3) — proved coefficientwise in any `CommRing R` that is a `ℚ`-algebra, with **no hypothesis on
> `B`**; the old proof target `MM.moebiusSum_adamsSum_holds` keeps its name and is now a theorem of
> the same statement, so that file carries **no unproved `Prop`** any more.  The paper's (10.4) ⇒
> (10.5) sentence is a theorem too (`MM.moebiusBlock_eq_zero_of_not_dvd`, `MM.multSum_restrict`),
> resting on `MM.sum_moebius_divisors`, `MM.divisors_gcd_eq_filter` and
> `MM.sum_divisors_filter_dvd_moebius`.  **No series occurs in either file**, so none of this touches
> `MM.adamsLog`, `MM.EulerSeries` or `MM.DenominatorIdentity`.  Dispatcher-verified by a from-scratch
> rebuild (`MMRootMultiplicityArith` → `MMRootMultiplicity` → `FinalCheck`, all `--- OK ---`, exit 0)
> and by an independent exact check of the inversion identity itself (50 random families, `k ≤ 60`).
> The remaining content of T2 is therefore **only** the denominator formula of §6--8.

> **SPLIT AND DISPATCHED (dispatcher, 2026-09-13).**  T2 as originally written is "prove
> `MM.DenominatorIdentity` for the moonshine family", i.e. the paper's §6--8 (monster Lie algebra,
> no-ghost theorem, twisted denominator formula) — no Lean machinery for any of it, and the largest
> gap in the project.  Its **§10 half is separable and is T2a**: the Möbius inversion (10.3) ⇒ (10.4),
> pure divisor arithmetic over the coefficient family.
>
> **The source is the author's own TeX** (`../Monstrous moonshine and monstrous Lie
> superalgebras.tex`; see `AGENTS.md`), which settles by quotation what the extracted text left open:
> * **(10.3)** is obtained "if we compare the logarithms of (10.1) and (10.2)"; the `pᵐ`-block form is
>   `Σ_{i | m} C_{m/i}(q^i)/i`, whose inversion is
>   `a_m(q) = Σ_{d | m} (μ(d)/d)·mult_{m/d}(q^d)` — coefficientwise (10.4).
> * **The summation subscript is DEFINED, not guessed.**  Immediately after (2.3) the paper says
>   *"(The symbol `(m,n)` under the summation sign means the greatest common divisor of `m` and `n`,
>   rather than the ordered pair.)"*  So `ds | (m,n)` means `ds | gcd(m,n)`.  **This question was
>   raised to the owner as an ambiguity and is closed by the source**: (2.3) and (10.4) are the same
>   formula with `(d,s)` renamed.
> * **(10.5)** is the paper's own simplification of (10.4): since `Tr(g^d|V_n)` depends only on
>   `(d, N)` with `N = ord g`, the sum `Σ_{ds=k} μ(s)Tr(g^d|·)` vanishes unless `k | N`, so the
>   subscript may be restricted to `(m,n,N)`.
> * The paper then uses this for the seven ATLAS classes (§9--10, (10.6)--(10.8)) and **states
>   explicitly that (9.1) itself is never used** — only that the coefficients for `n = 1,2,3,5`
>   determine all of them.  That is the sentence T3 should have been built on.

> **T2's UNSETTLED box, now SETTLED (after task T2-pre landed `Definitions/MMLogCoeff.lean`).**  The
> UNSETTLED box that stood here recorded two open questions and named the decisive step: derive the
> coefficient formula for `PowerSeries.logOf`.  That is done (`MM.coeff_logOf`), and with it both
> questions are answered — **one of them against the route this entry was built on.**  The material
> below is superseded where the two disagree.
>
> 1. **`MM.AdamsLogIsLog` is FALSE as a general identity** — `MM.not_adamsLogIsLog`, at the
>    coefficient of `p²`, by an explicit counterexample (trivial group, `c(1) = 1`, `bound = 1`)
>    that satisfies `MM.FiniteSupportCoeff`.  So it is not "the Möbius inversion" and cannot be
>    T2's target.  The reduction to a per-degree equality is `MM.adamsLogIsLog_iff`; the coefficient
>    of `adamsLog` is `MM.coeff_adamsLog` (a divisor sum, as the paper's `L` requires).
>    **Scope, and it matters:** the counterexample is **not** `MM.IsReplicable` (it violates the
>    recursion at `k = 2`, `mn = 1`: `c(4) + 2c(1) = 2 ≠ 0 = 2c(4)`), so **whether replicability
>    implies the `Prop` is not settled** by it, and no claim either way is made here.
> 2. **The real obstruction is the object, not a hypothesis on `c`.**  From the primary source
>    (the paper's text is in this workspace as `../mm_text.txt`, section 8 — read it, do not
>    reconstruct it), (8.3) is
>
>    `p⁻¹ · exp(− Σ_{i>0} Σ_{m>0, n∈ℤ} Tr(g^i|V_mn) p^{mi} q^{ni} / i) = Σ_{m∈ℤ} Tr(g|V_m) p^m − Σ_{n∈ℤ} Tr(g|V_n) q^n`,
>
>    i.e. `exp(−L) = p·(T_g(p) − T_g(q))`, and the right-hand side is **two-sided in `q`** — it
>    contains `−p·q⁻¹`, because `T_g = q⁻¹ + Σ_{n≥0} c(g,n)q^n` with `c(g,-1) = 1` (`V_{-1} = 1`
>    acts trivially, `V_0 = 0`).  `MM.EulerSeries`'s `q`-side is `qCoeffOf … bound 1`: **positive
>    `q`-powers only**, plus an extra `m = 0` term (`MM.constantCoeff_one_add_eulerSeries_ne_one`).
>    So `1 + EulerSeries` is *not* `p·(T_g(p) − T_g(q))`, and the earlier derivation's step
>    "`L` is the logarithm of `1 + E`" is not available.
>    **The shape is not refuted**: with the correct two-sided `E`, `−L = logOf (1 + E)` is just the
>    definition of the logarithm (T1b, `MM.expOp_logOf_eq`).  What is missing is the **two-sided
>    `q`-expansion object** — the same defect task **D0** already records and
>    `Definitions/MMQExpansionGap.lean` proves the limits of.  **That is T2's first requirement.**
> 3. **What T2 therefore is, restated.**  (i) Build the two-sided `q`-object and state (8.3) with it
>    (`E := p·(T_g(p) − T_g(q)) − 1`) — **(i) IS NOW DONE**: `MM.HasLaurentQExpansion` in
>    `Definitions/MMQExpansionTwoSided.lean` is that object, the series determined by `f` and the
>    level-one instance proved (`MM.levelOneJ_sub_hasLaurentQExpansion`); what remains of (i) is
>    **integrality** (`ℂ`-valued coefficients) and the restatement of (8.3) with it;
>    (ii) then the Möbius inversion proper — the equivalence
>    between `MM.IsReplicable` and the product form (10.1)/(10.4), for which `MM.coeff_adamsLog`
>    now supplies the Adams side in the right shape.  **Do not start from `logOf (1 + EulerSeries)`.**
>
> 4. **AND THE RESTATEMENT IS NOW DONE, WITH THE TARGET RE-SCOPED (task T2-ii, this session).**
>    `Definitions/MMDenominatorIdentity.lean` states (8.3) faithfully as `MM.DenominatorIdentity`,
>    after recording the two forced reformulations: multiply through by `p` (`PowerSeries` has no
>    negative `p`-exponents), and note that the paper's `q`-side is **two-sided and sits at `p¹`
>    alone** — so the right-hand side is `[p⁰] = c(g,-1)`, `[p¹] = c(g,0) − T_g`, `[p^k] = c(g,k−1)`
>    for `k ≥ 2`, *not* `c(g,k−1) − T_g` at every degree.
>    Proved: `MM.DenominatorIdentity.iff_coeff` (the honest per-degree reduction),
>    `MM.DenominatorIdentity.coeff_zero` — **the normalization `c(g,-1) = 1` is *derived* from the
>    identity**, not assumed — and `MM.DenominatorIdentity.coeff_one` (`c(g,0) = 0`, the FLM fact
>    `V_0 = 0`).
>    **Consequences for this entry, taken from the paper's own section 9:** the `p¹` comparison
>    carries no recursion; the `p²`/`p⁴` comparisons *are* the paper's recursion (9.1) and are task
>    **T3**; and **the Möbius inversion (10.4) is not a coefficient of (8.3) at all** — section 10
>    *defines* `mult(m,n)` by (10.4), inverting the recursion.  So what remains of T2 is exactly one
>    thing: **prove `MM.DenominatorIdentity` for the moonshine coefficient family**, i.e. the paper's
>    sections 6--8 (monster Lie algebra, no-ghost theorem, twisted denominator formula).  The
>    "Möbius inversion" is a definition plus a divisor-arithmetic lemma, not a series identity, and
>    the old T2a/T2b split below is superseded where it disagrees with this.
>
> **Also verified and worth not rediscovering:**
> `Finset.sum_Icc_eq_sum_range` does not exist; `ArithmeticFunction.sum_divisors_moebius` does not
> exist; the Möbius-inversion lemma that *does* exist is
> `ArithmeticFunction.sum_eq_iff_sum_mul_moebius_eq` (`Moebius.lean:238`), of the form
> `(∀ n > 0, Σ_{i|n} f i = g n) ↔ ∀ n > 0, Σ_{x ∈ n.divisorsAntidiagonal} μ x.fst * g x.snd = f n`.
> T2a does **not** depend on T1b (no `exp` appears on either side).

The paper's section 10 passes from the denominator formula

  `p⁻¹ ∏_{m>0, n∈ℤ} (1 − pᵐqⁿ)^{mult(m,n)} = T_g(p) − T_g(q)`   (10.1)

to the root multiplicities via Möbius inversion.  The *direction* determines what there is to prove:

* `mult` is **defined** by (10.4), `mult(m,n) = Σ_{d·s | (m,n)} μ(s)/(ds) · c(g^d, mn/(d²s²))`.  So
  (10.1)'s product is *not* something to prove — it is the definition of that product.
* What is to be proved is the **recursion** obtained by comparing (10.1)--(10.3) with the definition:
  for every `k > 0` and all `m, n` with `mn ≠ 0`,

    `Σ_{i | k} i · c(g^i, mn·(k/i)²) = k · c(g, mn·k²)`,

  which is exactly `MM.IsReplicable` as stated in `Definitions/MMMoonshine.lean`.  (The originally
  recorded four-step spine — step 3 was `MM.AdamsLogIsLog` — is superseded by the SETTLED box above,
  where `MM.AdamsLogIsLog` is refuted as a general identity; `MM.seriesIdentity_of_adamsLogIsLog` is
  the surviving shape.)  **Dependencies:** T1b (`ExpLogOf`) for the exponent comparison; T1's
  `EulerSeries`/`adamsLog` for the setup.

* Acceptance: build exits 0; no `sorry`/`axiom`; axioms the three standard ones; and the recursion
  stated for the true divisor sum (a statement that is true only up to a bound, or only for `k = 1`,
  must be labelled as such rather than presented as the theorem).

> **T3-RECON (2026-09-13): the determination statement was priced, and candidate (A) is FALSE.**
> A reconnaissance task (read-only; report `Probe/T3_DETERMINATION_RECON.md`) asked whether the
> paper's sentence — *"the coefficients for n = 1, 2, 3 and 5 determine all the coefficients"* — can be
> formalized **without** the four formulas (9.1), since only formulas 1 and 3 are theorems here.
>
> **Candidate (A) — determination from `MM.IsReplicable` alone plus agreement on the first few
> coefficients — is refuted, and not vacuously.**  The replicability relation for level `k` and index
> `p` exists only when `k² ∣ p`, so it never constrains a **squarefree** level.  Explicit
> counterexample: the perturbation `δ = 1` at `(g², 7)`, `2` at `(g, 28)`, `0` elsewhere satisfies every
> relation (the only one meeting its support is `(k,p) = (2,28)`: `2·1 − 2 = 0`) and vanishes on all
> inputs `n ∈ {1,2,3,5}` for every power.  Checked to `p = 200`; the pinned perturbation space has exact
> kernel dimension 3 at `B = 40` and 8 at `B = 60`.  So `IsReplicable` plus five coefficients does **not**
> determine the family, and the paper's claim is not a consequence of replicability alone.
>
> **What the claim actually needs, measured by rule-subset closure.**  Descent is by index: the formula
> for `n` names only smaller indices **except** at `n ∈ {1,2,3,5}`, where the recursion degenerates
> (F2 at `k = 1` gives `c(5) = c(5)` — the paper says so explicitly).  Exhaustive checks to `n = 4000`
> show: `F1 + F3` alone reaches only 9 of the first 400 indices; `F1+F3+F2` reaches 72;
> **`F1+F3+F2+F4` reaches all of them.**  So determination needs **all four** formulas — and the pair
> `{RecursionFormulaTwo, RecursionFormulaFour}` is the single decisive missing input, exactly where this
> stream stalled before (they are unproved `Prop`s in `MMReplicationFormulaTargets.lean` because the
> route that was supposed to produce them was refuted by T3e).
>
> **Two further findings worth keeping.**  (i) The published second formula fails against exact `j` at
> every `k` unless the sign correction already recorded in `MMReplicationFormulasOdd.lean` is applied;
> with it, all four formulas check at `k = 1..5`.  (ii) Norton's 12-coefficient theorem is *not* the
> route the paper's section 9 uses, and is not formalizable from the coefficient relations alone: it
> needs a strictly stronger notion than `IsReplicable`.  **Do not dispatch a determination task whose
> statement does not name `{F2, F4}` as an input** — it would be a slightly more elaborate version of
> the two refutations this stream already has on record.
>
> Verified API facts from the probes (`Probe/T3ReconProbe.lean`, `…Shine.lean`, both `--- OK ---`):
> `MMReplicationFormulaTargets` does **not** import `MMMoonshine`, so there is no import edge between
> the (9.1) machinery and `IsReplicable`; `IsReplicable` appears in no other `Definitions/` file; and
> `Nat.divisors_pos_of_pos` does not exist in this pin.

### [~] T3 — the recursion (9.1) from (8.3) — **first step landed (this session)**
* Deliverable: extraction of the paper's recursion (9.1) for `c_g(4k), c_g(4k+1),
  c_g(4k+2), c_g(4k+3)` from `MM.IsReplicable`, i.e. a theorem
  `MM.IsReplicable.recursion`.
* Acceptance: builds, no `sorry`.
* Risk: medium.  Purely combinatorial once T1 exists.
* **PROGRESS (this session).**
* **T3d + T3e (this session): the `p³` comparison landed, and then the ROUTE TO FORMULAS 2 AND 4 WAS
  REFUTED — the stream is stopped here on purpose.**  `Definitions/MMReplicationPThree.lean` (175 lines)
  lands `MM.DenominatorIdentity.pThree` / `…pThree_apply` — the first comparison in which
  `c(g,4k+1)` and `c(g,4k+3)` occur at all (it also settled the paper's `p⁻¹` shift: the paper's
  "compare `p²` and `p⁴`" is this repository's `p²`, `p³`, `p⁴`).  `Definitions/MMReplicationFormulaTargets.lean`
  (124 lines) records formulas 2 and 4 as **`Prop`-valued targets** — not theorems — because T3e
  established, by exact polynomial computation in the symbols `c(g^i,n)`, that they lie in **no linear
  combination** of (8.3)'s coefficient relations (residual 7--8 terms for `p`-degree `≤ 6`,
  `q ∈ [−8,26]`), nor of the reciprocal presentation `exp(L)·p(T(p)−T(q)) = 1`, nor after adjoining
  products of relations.  **The dispatcher independently reproduced the span test** (validated by the
  self-check that formulas 1 and 3 *are* single relations) **and tested the two natural repairs, both
  of which failed**: adjoining (8.3) for `g, g², g³, g⁴` (60 → 240 relations) leaves the residuals stuck
  at 19 and 9 terms, and the **replicability** relations (the divisor recursion, `k ≤ 6`, `|P| ≤ 12`) do
  not span them either.  The formulas are nevertheless **true** (checked at `k = 1…5` against `j`
  recomputed from `E₄ = 1 + 240Σσ₃(n)qⁿ` and `Δ = q∏(1−qⁿ)²⁴`).  **Conclusion: the paper's "elementary
  algebra" sentence is not reproduced by any route tried; the extra input that would yield formulas 2
  and 4 is unidentified, and no further elimination round should be scheduled until it is found.**
  Two docstrings on `main` that asserted the refuted route (`MMReplicationPThree.lean`'s title/§1/§3 and
  `MMDenominatorIdentity.lean`'s §4 bullet) were corrected; the file headers and the README carry the
  evidence.
* **Formulas 1 and 3 ARE landed (task T3b), and they are conditional on `MM.DenominatorIdentity`.**
  `Definitions/MMReplicationRecursion.lean` (145 lines) derives the **`p²` comparison** of (8.3) from
  `MM.DenominatorIdentity`: `MM.coeff_expOp_two` (the general `p²` coefficient of the exponential) and
  `MM.DenominatorIdentity.pTwo` / `.pTwo_apply`.  `Definitions/MMReplicationFormulas.lean` (498 lines)
  contains `MM.DenominatorIdentity.cg_four_mul` and `…cg_four_mul_add_two` **verbatim at the paper's
  ranges and its `k ≥ 1`**, with every implicit hypothesis explicit — the FLM grading `c(g,n) = 0` for
  `n < −1` (not derivable from `FiniteSupportCoeff`; it confines the convolution to finite ranges),
  `c(g,0) = 0`, and the truncation bound — while `c(g,-1) = 1` is *derived* from (8.3).  Both readings
  are verified numerically against the true `j`-coefficients (first formula at `k = 1, 2`, third at
  `k = 1`).  The extraction chain (convolution normal form, the two collapses, the pairing lemmas via
  `j ↦ 2k−j`, the evaluated square coefficients, `[p²]L = E₂ + ½ψ²(E₁)`) is reusable.
* **T3c: the `p⁴` comparison landed, and TWO FINDINGS that changed the next step.**
  `Definitions/MMReplicationFormulasOdd.lean` (303 lines) has `MM.coeff_expOp_four` and
  `MM.DenominatorIdentity.pFour` (+ its coefficientwise form), all conditional on `MM.DenominatorIdentity`.
  **Finding 1 — the paper's second formula is WRONG AS EXTRACTED.**  The paper says the recursion
  degenerates at `n = 5`; the extracted sign gives `c_g(5) + c_g(2)²` there instead of `c_g(5)`.  With
  `(cg2(2k) − cg(2k)²)/2` in place of the first square term it degenerates exactly and holds at
  `k = 2, 3`.  Both the file's author and the **dispatcher, independently**, checked this numerically
  (extracted: `462314921578200` against `c(5) = 333202640600`; corrected: exactly `c(5)`, then
  `c(9) = 3176440229784420`).  The correction is **recorded and not applied**: no theorem states
  formulas 2 or 4, precisely so that a false statement cannot enter.
  **Finding 2 — the route to formulas 2 and 4 is NOT the coefficient comparison.**  `c(g,4k+1)` can only
  enter `pFour` through an `L₁` factor, whose surviving contributions carry `c(g,0) = 0` or
  `c(g,-1) = 1` — yet formula 2 contains the ALTERNATING sum `Σ_{1≤j≤2k}(−1)^j cg(j)cg(4k−j)`.  No
  coefficient comparison of `exp(−L) = p(T(p) − T(q))` produces alternating signs; they come from a
  reciprocal/product (`(1+X)^{-1}`-type) expansion, or from combining the `p²` and `p⁴` comparisons to
  eliminate a term — **which one is not established**.  The `p²` comparison at `q^{2k+1}` is *minus*
  formula 3 (no new information at odd degrees), `c(g,4k+1)`/`c(g,4k+3)` do **not** occur in the `p²`
  comparison at `q^{4k+1}`/`q^{4k+3}` at all, and no single comparison *is* the formula: the `p³`
  comparison at `q⁹` has 26 monomials against the formula's 11.  The route actually taken is the (8.3)
  comparison, not `MM.IsReplicable` as the deliverable line above says; the relationship between the two
  is *not* assumed and is recorded as open in the file header.

### [ ] T4 — generalized Kac--Moody algebras (the long game)
* Deliverable: not attempted here.  Recorded for completeness: the paper's sections 4--8 need
  the definition of a generalized Kac--Moody algebra, its denominator formula, Lie algebra
  homology `H(E)` and its identification with the sum over the Weyl group, and the no-ghost
  theorem.  None of this exists in Lean.  This is the single largest gap in the whole
  project and should be scoped as a multi-month effort.

---

## THE LONG CAMPAIGN — discharging the four assumed inputs outright

The four assumed inputs are listed in `README.md`; this section is the plan for removing them, as
opposed to the task-by-task list below.  It exists because the goal of the project is Theorem 1.1
**unconditional**, and the honest scoping of that differs enormously between the four.

### Measured state of the foundations (COMPILED inventory, this revision)

| what is needed | what exists | verdict |
| --- | --- | --- |
| vertex algebras (for FLM) | Mathlib `Algebra/Vertex/`: `VertexOperator.lean` (98 lines) + `HVertexOperator.lean` (161 lines) = **259 lines**, with `Locality`, `HasseDerivative` and `Residue products` still in their `## TODO` | **not a foundation**; vertex algebras, modules, and the state--field correspondence would all be from scratch |
| the Leech lattice Λ (for `V_Λ`) | nothing in Mathlib, nothing in MM | from scratch; an even unimodular rank-24 lattice with no roots |
| Γ₀(N) | `MM` has **no definition at all** — `Γ₀(11)` appears only in documentation; Mathlib's `CongruenceSubgroup.Gamma N` is the *principal* congruence subgroup `Γ(N)`, not `Γ₀(N)` | must be built, or imported from FLT |
| genus of `X₀(N)` | FLT proves `genusFormula` **unconditionally in characteristic 0**; its `Definitions` layer is importable in ~5 s | **the one piece that is genuinely available** |
| `Γ₀(N)⁺` (the normalizer, which the table actually needs) | nothing in Mathlib or FLT | from scratch |
| the monster group | `MM.Monster`, by the Norton--Ivanov presentation, as a *definition* (`Definitions/MMMonster.lean`) | defined; finiteness and order are task S3 |
| the monster's character table | nothing anywhere | from scratch, and needed for the section 9 case check |
| no-ghost theorem | nothing | the single hardest item |

### M1's COST WAS MIS-STATED: the arithmetic half is 140 lines and needs no FLT (measured)

> **The claim that `decide`/`norm_num` cannot recompute the genus-zero list, and that the 2297-line
> FLT file is therefore necessary, is REFUTED for the arithmetic half.**
>
> Measured: `Probe/ProbeArithFull.lean` — **Mathlib only, 0 FLT imports, 140 lines, compiles**,
> `#print axioms` exactly the three standard axioms, containing
> `genusZero_level (N) (hN : N ∈ genusZeroLevels) : genusFormula N = 0` for the 15 Conway--Norton
> levels and `genusFormula_eleven : genusFormula 11 = 1`.  The `genusFormula` there is `rfl`-equal to
> FLT's, so nothing is lost by not importing it.
>
> **The two real blockers, each removed by one rewrite** (measured on `N = 2` and `N = 11`):
> * `Nat.card` does not kernel-reduce, so bare `decide` fails on `nuTwo`/`nuThree`; the fix is
>   `rw [Nat.card_eq_fintype_card]`, which needs `[NeZero N]` and so is applied at a numeral.
> * **`Squarefree` does not kernel-reduce** — `Nat.instDecidablePredSquarefree` goes through
>   `Nat.minSqFac`, a well-founded recursion; `decide` cannot prove even `Squarefree 2`, and the
>   `norm_num` squarefree prover is **commented out in this Mathlib pin**
>   (`Mathlib/Data/Nat/Squarefree.lean`, "Porting note: comment out NormNum tactic").  A 25-line
>   bridge (`squarefree_iff_of_le_twentyfive`, via `Nat.squarefree_iff_prime_squarefree` +
>   `interval_cases`) replaces it with divisor arithmetic for `n ≤ 25`, which is all the levels need.
> Everything else (`Nat.divisors`, `Nat.totient`, `Nat.gcd`, `Nat.div`, `Fintype.card` over `ZMod`
> at literals) reduces fine.  The final `ℚ` equality is easier as the integer relation
> `12 + ψ = 3ν₂ + 4ν₃ + 6·cusps`.
>
> **What the 1115 figure actually belongs to.**  It is real, and it was reproduced exactly — but it
> is the *geometry*: `Thm_ModularCurve_genus_modularFunctionFieldBar_eq_genusFormula` (510 Theorems +
> 511 P2M + 94 Definitions).  And that theorem is **conditional** on
> `HasCanonicalDivisor (AlgebraicClosure ℚ)`; FLT supplies that instance only for `K := ℂ`.  The
> cheapest **unconditional** genus identity is the **1656**-module
> `genusFF_modularFunctionFieldFullC_eq_genusFormula_algebraicClosure` (≈16 h floor, and with 4.2 GB
> peak RSS per `lean` process it is effectively serial).  The **arithmetic** closure is **6
> modules**, measured at **165.7 s**.  So: a number costs minutes, the *identification* costs
> overnight-plus.
>
> **`Def_CohCarrier_Level` (broken in FLT) is in none of the closures we need** — 0 hits in the 6-,
> 1115-, 1297- and 1656-module closures.  It blocks `Def_ModularCurve_XH`, which is not needed.
>
> **`Γ₀(N)` and the bridge.**  MM mentions `Gamma0`, `CongruenceSubgroup` and Atkin--Lehner
> **nowhere** in its own sources; the missing one-liner is
> `Gamma0GL N := Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma0 N)`
> (compiles).  `Γ₀(N)⁺` has nothing at all — no Atkin--Lehner, no Fricke, no normalizer in Mathlib,
> and FLT has only the *operator* `AtkinLehnerDatum`/`alSlash` on forms.
>
> **The honest limit of the arithmetic file.**  `genusFormula N = 0` is arithmetic about a
> definition.  It establishes **nothing** about `Γ₀(N)`, `X₀(N)`, `ℍ/Γ` or Hauptmoduls; the
> identification "this formula = the genus of `X₀(N)`" is the whole geometric content and is
> untouched.  The next honest step is the **η-quotient** route (Mathlib has
> `NumberTheory/ModularForms/DedekindEta.lean` with `eta`, `eta_ne_zero`, `logDeriv_eta_eq_E2` —
> but **no** S-transformation law `η(-1/z) = √(-iz) η(z)` and no multiplier system), and even that
> yields only "here is the explicit `f` with the right `q`-expansion and modularity", **not**
> `IsHauptmodul`: orbit separation is the degree-1/argument-principle condition on `X(Γ)` and stays
> open (the `f = j²` counterexample in `README.md` is why).
>
> **Restated in one line, since this box and the `M1` entry below both carry it:** the *genus number*
> is available from FLT (arithmetic closure 6 modules / 165.7 s; geometry conditional, 1656 modules
> unconditional), and what is missing is the **bridge** from FLT's algebraic function field to MM's
> analytic `ℍ/Γ`.

### A THIRD EXTERNAL DEVELOPMENT — AND IT IS THE VERTEX-ALGEBRA FOUNDATION ITSELF

> **`dbrueg/lean-geometric-vertex-algebras` (GeomVA).**  Downloaded, inspected and **fully compiled
> by the dispatcher**: **18/18 modules, 0 errors, ~4 minutes total**, against **our exact pin** —
> Lean `v4.33.1` / Mathlib `v4.33.1`.  **No port is needed.**  **16,077 lines** in 18 files,
> formalizing Daniel Bruegmann, *Geometric Vertex Algebras*, arXiv:2012.09717 (Graduate J. Math. 10
> (2025) 1--20), with the paper's LaTeX source in the repository.  By module:
> * `Formal/Dist.lean` (476 lines) — **the formal-calculus layer that was missing**: `FormalDist M`
>   = `M[[x^{±1}]]` with mode indexing, `FormalDist₂`, `mulX`, `deriv`, `IsCreation`, `idDist`,
>   `mulXSubY`, `mulXSubYPow` (closed binomial formula), `commutator`, `prodApply`, `NoNegY`,
>   `setYZero` — the bookkeeping of the vertex axioms (Def 3.1 of the paper);
> * `Analytic/` (5 files, ~3,900 lines) — holomorphic functions on domains in `ℂⁿ` (Def 1.1), normal
>   convergence and sums in a vector space *without* topology (Def 1.4), circle-integral lemmas
>   **missing from Mathlib** including analyticity in a parameter, Laurent expansions on annuli
>   (Def 2.8), `ℂⁿ ∖ Δ`, the domains `D_m`, `U_ij`, `U_{r,R}`;
> * `Graded/Basic.lean` — `ℤ`-graded spaces, the `ℂ^×`-action, homogeneous maps (Def 2.5);
> * `VA/Defs.lean`, `GVA/Defs.lean`, `GVA/Modes.lean` — **`GeomVA.VertexAlgebra`** and
>   **`GeomVA.GeometricVertexAlgebra`**;
> * `GVAtoVA.lean` (2,229 lines) and `VAtoGVA.lean` (4,265 lines) — **both directions of the
>   equivalence**, proved; `Equivalence.lean`, `Category.lean` — the main theorem.
>
> **Verified main results** (the dispatcher re-checked every `#print axioms`):
> `GeomVA.VertexAlgebra.Phi_Psi`, `GeomVA.GeometricVertexAlgebra.Psi_Phi`,
> `GeomVA.GradedHom.isGVAHom_iff_isVAHom`, and
> **`GeomVA.PhiCatIso : Cat.of GVACat ≅ Cat.of VACat`** — an isomorphism of categories between
> geometric vertex algebras and `ℤ`-graded vertex algebras.  All four print exactly
> `[propext, Classical.choice, Quot.sound]`.  The `sorry` tokens in the tree are **six docstring
> occurrences of the phrase "no `sorry`"**; there are none live.
>
> **What this changes.**  The `vertexAlg` axiom layer (vendored earlier) and Mathlib's 259 lines are
> no longer the state of the art here: **this is a complete, compiled, paper-backed formalization of
> vertex algebras** — and, through the geometric side, the contour-integral construction route rather
> than the abstract Borcherds-identity route.  **What it still does NOT contain** (grepped): nothing
> about lattices, the Leech lattice, the monster, moonshine, generalized Kac--Moody algebras, the
> no-ghost theorem, or lattice vertex operators `e^λ`.  So the *concrete* objects remain to be built;
> what is available is a **working, complete vertex-algebra theory to build them in**, on our pin.

### EXTERNAL FOUNDATION, FOUND — TWO developments, both measured, neither ported

> **`ScottCarnahan/vertexAlg`** — downloaded and measured directly (not from its README):
> **35 files, 10,772 lines, 0 active `sorry`/`admit`/`axiom`** after comment-stripping.
> `VertexBasic/Defs.lean` defines `stateField`, `order`, `associativity`, `commutatorFormula`,
> `IsLocal`, `T`, `skewSymmetry`, `translationCovariance` and **`class VertexAlgebra`**;
> `VertexBasic/Borcherds.lean` defines the Borcherds sums and **`class VertexAlgebra1`** axiomatized
> by the Borcherds identity, and **proves** `borcherdsId_at_zero_iff_associativity`,
> `borcherdsId_at_zero_iff_commutatorFormula`, `locality_left_eq_borcherdsSum2`,
> `locality_right_eq_borcherdsSum3` and the `Borcherds_sums_2_3_eq_if_locality` pair, plus a
> hom/subalgebra/equivalence API and a Lie layer (`Lie/Loop.lean`, `Cocycle.lean`,
> `CentralExtension.lean`, `ChevalleyEilenberg.lean`, `PBW.lean`).  **But not one concrete vertex
> algebra is instantiated**: `VertexBasic/Lattice.lean` is a 34-line stub with no definitions,
> `VertexBasic/Affine.lean` has its `positiveEnergy`/`smooth` classes commented out, and its own TODO
> names Golay-24, Mathieu₂₄, the Leech lattice, lattice VOAs, the `-1`-twisted module, the `-1`
> orbifold, generalized Kac--Moody algebras, the **no-ghost theorem** and Hauptmoduls.
>
> **So the foundation question is now sharp:** the *axiom layer* exists (twice over, with
> `VirasoroProject` covering the Virasoro/Heisenberg/Fock/Sugawara side at `c = 1`), and **every
> concrete object is missing**.  **Two measured corrections that change the phasing.**
>
> 1. **The no-ghost theorem does NOT need a rank-24 lattice.**  Theorem 5.1's hypotheses are a
>    nonsingular form, a Virasoro action with `L_i† = L_{-i}` and central element `24`, `L_0`
>    diagonalizable over `ℕ` with finite-dimensional eigenspaces, and a group `G` preserving the
>    structure.  Only `II^{1,1}` (rank **2**) appears.  The paper says so itself after Theorem 6.1:
>    the construction works for any vertex algebra with a conformal vector, "but it is only when this
>    vector has dimension 24 that we can apply the no-ghost theorem".  So `E8³` or `D24⁺` suffice.
> 2. **The Leech lattice is forced by the moonshine module, by arithmetic.**  For `V_Λ` with `Λ` even
>    unimodular of rank 24, the `L_0 = 1` space has dimension `24 + #{λ : λ² = 2}`, while
>    `j - 744 = q⁻¹ + 0 + 196884q + ⋯` has vanishing `c(0)`; so `c(0) = 0` forces the lattice to have
>    **no roots**, and the Leech lattice is the unique such lattice.  (Computed: Leech `0` roots,
>    `E8³` `24 + 720 = 744`, `D24⁺` `24 + 1104 = 1128`.)  `V_Λ` itself still has a 24-dimensional
>    weight-1 space — **the orbifold is what removes it**, so "`V_Λ` already has the right character"
>    is false.
>
> **What the paper actually consumes, and a load-bearing simplification.**  The paper's conditions
> (1) vertex algebra over `ℝ` with a conformal vector of dimension 24 and a positive definite form,
> and (2) `V = ⊕ V_i` with `V_i` the `L_0 = i+1` eigenspace and `∑ dim V_i q^i = j - 744`, **alone
> imply that for any automorphism `g` preserving the structure, `∑ Tr(g|V_i) q^i` is completely
> replicable, i.e. (8.3) holds.**  The monster is needed only for condition (3) (the action) and for
> section 9.  So the replication identity — one of the four assumed inputs — follows from (1)+(2).
>
> **Indexing trap, frozen before any statement is written:** the paper's `V_i` is the `L_0 = i+1`
> eigenspace, but Theorem 5.1's `V^i` is the `L_0 = i` eigenspace, and `V^i = V_{i-1}`; `dim V_0 = 0`
> gives `V^1 = 0`, hence `dim M_{0,0} = 2 = ℝ²` (the Cartan), consistently.
>
> **Measured negatives, so nobody re-searches them.**  No formalization of moonshine, `V^♮`, the
> Griess algebra, a generalized Kac--Moody/Borcherds algebra, a lattice VOA, or the no-ghost theorem
> exists in **any** proof assistant (Isabelle/AFP entry URLs scanned, Coq/Rocq, Agda, Metamath,
> Mizar, HOL Light).  The only machine-checked Monster artifact anywhere is a 44-line Lean 3
> *definition* in the frozen 2019 `formalabstracts` repo — which is what `MM.Monster` already is, so
> **stream S is at the state of the art and S3 (finiteness and order) has no precedent anywhere.**
> `JustinMcClung/formal-distribution` (formal calculus, ~3850 lines, reported `sorry`-free) is now
> **404** — do not plan around it.
>
> **Revised dependency note.**  The construction graph is **not a chain**: the no-ghost sub-theorems
> need neither the Leech lattice nor the monster action, and the rank-2 Lorentzian Virasoro module
> can be built directly without constructing a vertex algebra at all.  The pivot object for
> everything downstream is **`V_{II^{1,1}}` — the first concrete vertex algebra** — because it is
> what the no-ghost *statement* names and what the tower is built from.
### EXTERNAL FOUNDATION, FOUND — and why it changes Phases 3/4 (measured, port UNVERIFIED)

> **An external Lean 4 development already contains the Virasoro / Heisenberg / Fock / Sugawara
> layer that this repository has nothing of.**
>
> * Kalle Kytölä, `VirasoroProject` — <https://github.com/kkytola/VirasoroProject>, docs
>   <https://kkytola.github.io/VirasoroProject/>, paper arXiv:2510.21741, *Virasoro algebra and
>   Sugawara constructions formally in Lean* (Oct 2025).
> * ~3058 lines over ~11 core files; reported `sorry`/`admit`/`axiom`-free (the reconnaissance
>   grepped the downloaded sources rather than trusting the README).
> * Contents: the Witt algebra and its 2-cocycle; the Virasoro algebra as the corresponding central
>   extension; `H²(Witt)` one-dimensional; the Heisenberg algebra; a Fock space and
>   `ChargedFockSpace`; the bosonic **Sugawara construction** (`VirasoroProject.sugawaraRepresentation`,
>   a Virasoro representation of central charge `1` from any locally-truncated Heisenberg
>   representation); Verma modules with a triangular decomposition; and a
>   Lie-algebra-representation-from-basis layer.
> * It does **not** contain lattice vertex algebras, vertex operators `e^λ`, the rank-2 Lorentzian
>   `II^{1,1}` VOA, the no-ghost theorem, or anything moonshine — verified by the reconnaissance,
>   not assumed.
>
> **THE PORT IS UNVERIFIED AND MUST NOT BE ASSUMED.** `VirasoroProject` pins
> `leanprover/lean4:v4.27.0-rc1`; this repository pins **Lean 4.33.1 / Mathlib `db584cd6`**. Nobody
> has compiled it against our pin. The few Mathlib names it is known to use are present in our pin
> (`LieModule.Cohomology.twoCochain`/`twoCocycle`, `LieAlgebra.loopAlgebra`,
> `UniversalEnvelopingAlgebra`, `TensorProduct.LieModule.lieRingModule`/`lieModule`), but that is a
> handful of `#check`s, **not** a compile. A dedicated port-feasibility task is measuring the real
> drift (file-by-file, error-by-error, classified as rename vs signature change vs elaboration
> change) before anything in this repository depends on it. **Do not cite this box as evidence that
> the layer is available.**
>
> **What it changes if the port is cheap.**  Phase 3 becomes "state the no-ghost theorem, having
> ported the Virasoro/Heisenberg/Fock/Sugawara layer" rather than "build that layer and then state
> it".  Phase 4's bottleneck moves *up* the stack: from "there is no vertex algebra foundation at
> all" to "there is no **lattice** VOA, no vertex operators, and no tensor product of Virasoro
> modules" — the last matters immediately because the paper's §5 no-ghost argument runs on
> `V ⊗ V_{II^{1,1}}`.  **Correction to the phasing paragraph below:** Phase 3's no-ghost *proof* is
> independent (lemmas 5.1--5.5 are abstract linear algebra), but its *statement* is not, because it
> names `V_{II^{1,1}}` and a tensor product that exist nowhere.

### THREE CORRECTIONS THAT SHARPEN THE PLAN (one removes a library from the critical path)

> **1. `Λ(E) = H(E)` is NOT a consequence of the no-ghost theorem, and Lie-algebra homology is NOT
> on the critical path to (8.3).**  The paper's §2 (`mm_text.txt:900-905`) derives it from the
> standard Chevalley--Eilenberg sequence `… → Λ²(E) → Λ¹(E) → Λ⁰(E) → 0`: it is the
> Euler-characteristic identity — the alternating sum of a complex equals the alternating sum of its
> homology.  It holds for every generalized Kac--Moody algebra, independently of no-ghost, and is
> reused as (8.1) in §8 and again in §13.  An earlier reconnaissance wrongly made no-ghost necessary
> for it.  **The task is split:** `T3a` is `Λ(E) = H(E)` (free Euler characteristic; Mathlib already
> has `⋀[R]^n M`), `T3b` is the replication identity (8.3) via §7's simple roots and the explicit
> `H_i(E)`.
>
> **What no-ghost actually supplies** is: (i) `M := (P¹/DP⁰)/radical` is a well-defined
> `II^{1,1}`-graded Lie algebra; (ii) `M_{(m,n)} ≅ V_{mn}` — the root multiplicities; (iii) positive
> definiteness in every non-zero degree, which is what makes `M` a GKM algebra.  So plan on deriving
> **"`M` is a GKM algebra with root multiplicities `V_{mn}`"** from no-ghost, not `Λ(E) = H(E)`.
>
> **2. The corrected chain, with its four independent gaps.**
> no-ghost ⇒ (`M` is GKM with root multiplicities `V_{mn}`) ⇒ plus §7's determination of the
> **simple** roots (from the product formula (7.1) for `j`, i.e. from modularity and Hecke operators —
> *not* from no-ghost; no-ghost gives root *multiplicities*, and (7.1) then determines the *simple*
> roots) ⇒ plus §4's free homological algebra ⇒ (8.2) ⇒ Adams operations and traces ⇒ (8.3) ⇒ §9 and
> Koike ⇒ Theorem 1.1.  The gap between no-ghost and (8.3) is therefore four independent items: the
> VOA/Lie-algebra construction; the GKM axioms; the simple roots (§7); and virtual-module-to-trace
> identities (Adams operations `ψⁱ`, the splitting principle, pointed-cone finiteness).
>
> **3. §5 of the paper is explicitly a sketch.**  `mm_text.txt:949-951`: "For convenience we give a
> quick sketch of their proof", with the full proofs referred to Goddard--Thorn and to I. Frenkel
> (1985).  A formal proof must fill in the zigzag `H ⊃ P ⊃ S, N, T, K` via Lemmas 5.1--5.5; it cannot
> transcribe §5.
>
> ### The smallest case is pinned, and the target for Phase 3 is now sharp
>
> Hypothesis (3) pins `c = 24` exactly, and the only freedom is to replace `II^{1,1}` by an even
> unimodular Lorentzian lattice of rank `26 - c`, which exists only when `26 - c ≡ 2 (mod 8)`, i.e.
> **`c ∈ {24, 16, 8, 0}`**.  There is **no `c = 1` case and no vacuous instance**, so the search space
> for a "smallest case" is genuinely tight.
>
> **Target: `V` = the rank-24 Heisenberg VOA (24 free bosons) tensored with `V_{II^{1,1}}`, with
> conclusion `dim (P¹_r / null) = p₂₄(1 - r²/2)`.**  This is the classical Goddard--Thorn theorem in
> its cleanest form, it is finitely decidable, and the partition numbers `p₂₄` appear verbatim in both
> the monster and the fake-monster formulas.  The literature agrees on the order: (1) rank-24
> Heisenberg × `II_{1,1}`; (2) the Leech case `V_Λ` = the fake monster — the first case giving a real
> `Λ(E) = H(E)` with an explicit denominator formula, avoiding FLM's construction of `V^♮`; (3)
> `V^♮` and the monster.
>
> ### Bibliography corrections — three names that must not be cited
>
> * The no-ghost paper is **P. Goddard, C. B. Thorn, *Phys. Lett. B* **40** (1972) 235--238**,
>   "Compatibility of the dual Pomeron with unitarity and the absence of ghosts in the dual resonance
>   model", doi:10.1016/0370-2693(72)90420-0.
> * There is **no** Goddard--Thorn paper titled "Unitary representations of the Virasoro algebra and
>   a no-ghost theorem" (INSPIRE: 40 no-ghost titles, none this one; Goddard--Thorn have exactly
>   three joint records).
> * **"Frenkel--Goddard--Olive" appears not to exist** — INSPIRE has 0 records for the three authors,
>   zbMATH 0 for Frenkel&Goddard and 0 for Frenkel&Olive.  It looks like a conflation of
>   Frenkel--Lepowsky--Meurman with Goddard--Olive, *Algebras, lattices and strings*, MSRI Publ. 3
>   (1985).  The genuine `c = 24` generalization is **I. B. Frenkel, *Lect. Appl. Math.* **21**, AMS
>   (1985) 325--353**.
> * Kac's *Vertex Algebras for Beginners* and the FLM book **do not contain** the no-ghost theorem
>   (checked against tables of contents).
> * Rigour caveat to carry: Borcherds states that Goddard--Thorn's proof *is* rigorous;
>   S. Parrott, *Results in Math.* **21** (1992) 379--395 argues the contrary.  The disagreement is
>   unresolved in the literature, so a formalization is not merely a transcription in either case.
>
> ### Indexing: fix it in ONE place before any statement is frozen
>
> Two independent opportunities to get the indexing wrong, both now measured:
> * the paper's `V_i` is the `L_0 = i+1` eigenspace while Theorem 5.1's `V^i` is the `L_0 = i`
>   eigenspace, with `V^i = V_{i-1}`;
> * the distributed `monster.tex` §6 reads "degree `1 - (m,n)²/2 = 1 - mn`", but with the stated Gram
>   matrix `((0,-1),(-1,0))` one has `(m,n)² = -2mn`, so the consistent reading is `1 + mn`, matching
>   Theorem 6.1(3) `M_{(m,n)} ≅ V_{mn}` and §12's norm `λ² - 2mn`.  **The TeX appears to carry a sign
>   slip; take Theorem 6.1(3) as authoritative.**
>
> **RESOLVED IN CODE, and the resolution reverses this entry's sign.**  `Definitions/MMLatticeDoubleCover.lean`
> **freezes `II^{1,1}`'s Gram matrix as `((0,1),(1,0))`** — positive off-diagonal — so that for
> `λ = m·e + n·f` one has `(λ,λ) = 2mn` and `λ²/2 = mn`.  That makes Theorem 6.1(3)'s degree
> `1 - mn` (equivalently `1 - λ²/2`) the *consistent* reading, matching `M_{(m,n)} ≅ V_{mn}`, and the
> `1 + mn` above belongs to the *other* sign convention `((0,-1),(-1,0))`.  The two conventions differ
> by the isometry `n ↦ -n`; **mixing them is a sign error**, so the convention used is recorded in the
> module docstring and every downstream statement must name it.  What is still *not* frozen anywhere is
> the `L_0`-grading convention (`V_i` with `L_0 = i+1` versus `V^i` with `L_0 = i`) — nothing written
> so far is graded, so that trap must be frozen in the file that first states the no-ghost theorem.
>
### LEECH LATTICE: CONSTRUCTION FOUND AND NUMERICALLY VERIFIED — and why two attempts failed

> **The construction.**  `Λ = 2^{-3/2} · A`, where
>
> ```
> A := { a ∈ ℤ²⁴ :  a₁+⋯+a₂₄ ≡ 4a₁ ≡ ⋯ ≡ 4a₂₄  (mod 8)
>                  and for each residue class mod 4, the 24-bit word whose 1s mark the
>                  coordinates i with a_i in that class is a codeword of the binary Golay code }
> ```
>
> with the form `(x,y) = (Σ xᵢyᵢ)/8` on `A`.  This is the Conway--Sloane SPLAG Ch. 4 §4.9
> "even coordinate system" description.
>
> **Why two earlier attempts produced zero norm-4 vectors — the diagnosis is worth keeping.**
> **No construction of the shape "`Λ ⊆ ℤ²⁴` with the standard dot product" can possibly work.**  A
> finite-index sublattice of the unimodular `ℤ²⁴` has determinant equal to the square of its index,
> so determinant `1` forces index `1`, i.e. the whole of `ℤ²⁴`, which has roots.  **The `1/√8`
> scaling is essential**, and `A` genuinely has index `2³⁶` in `ℤ²⁴`: `det(A, (·,·)/8) = 2⁷²/8²⁴ = 1`.
> A future attempt that drops the scaling is wrong before it starts.
>
> **Numerically verified** (script `Probe/leech_verify.py`, run end to end, "ALL CHECKS PASSED"):
> * the Golay code from the cyclic quadratic-residue code of length 23 plus a parity bit: `|C| = 4096`,
>   weights `{0, 8, 12, 16, 24}`, weight enumerator `1 + 759q⁸ + 2576q¹² + 759q¹⁶ + q²⁴`, linear and
>   self-orthogonal, hence self-dual;
> * all 48 explicit generators lie in `A`; the index `[ℤ²⁴ : span(gens)] = 2³⁶` by integer HNF, equal
>   to the independently counted `|A/8ℤ²⁴| = 2³⁵ + 2³⁵`, so the generators span `A`;
> * `(A, (·,·)/8)` is integral, even, of determinant `1`, and positive definite (Sylvester minors);
> * the minimum of `a·a` over non-zero `a ∈ A` is exactly **32**, so `Λ` has **no vectors of norm 2,
>   4 or 6** — minimum norm **4**;
> * a complete enumeration gives exactly **196560** vectors of norm `32`, in the three shapes, with
>   the count factorisations read out of the source:
>   `1104 = 4·C(24,2)` of multiset shape `(4,4)` (support 2);
>   `97152 = 759·2⁷` of shape `(2,2,2,2,2,2,2,2)` (support 8, i.e. `2⁸` on a Golay octad);
>   `98304 = 4096·24` of shape `(3,1,1,…,1)` (support 24);
>   equivalently `196560 = 4·C(24,2) + 759·2⁷ + 4096·24` — matching the source exactly.
>   (An earlier note in this entry wrote the third shape as `(3,1²³)` and did not explain the factor
>   `24`; the correct factorisation of `98304` is `4096·24`, and `1²³` is the component multiset, not
>   the count.)
>
> **Consequence for the plan: this is elementary.**  Integer congruences plus a finite check over a
> 4096-word code.  No SPLAG Ch. 10 machinery, no Niemeier or "holy construction" theory, no uniqueness
> theorem.  Every one of the five bullets above is a **finite computation** on a finite set, so a Lean
> formalization can be entirely concrete: state `A` as a subtype of `Fin 24 → ℤ` with the congruences
> and the Golay condition, and prove the norm facts and the count over that finite set.  (The count of
> norm-32 vectors is the expensive one and should be budgeted the way section 11's `thetaCoeff` was.)
> The crystallographic point that must not be lost: `Λ` lives in `ℝ²⁴`, not in `ℤ²⁴`, and norms are
> `Σ aᵢ²/8` on the integer representatives.
### LEECH: MILESTONES, MEASURED TRAPS, AND A SOURCING WEAKNESS THAT MUST BE STATED

> **Sourcing weakness, stated plainly.**  There is **no copy of SPLAG in this workspace.**  The
> construction above was read from **two independent online expositions** — the HandWiki mirror of the
> Wikipedia article (§"Using the binary Golay code", HTTP 200) and PlanetMath's `leechlattice`
> (HTTP 200) — which agree with each other, and it was then **verified from scratch by computation**
> (independently re-run by the dispatcher: `ALL CHECKS PASSED`).  So the *construction* is not in doubt,
> but its *primary citation* is not in this workspace.  Anyone writing it into a docstring must cite
> SPLAG Ch. 4 §4.9 and note that it was checked against two secondary sources rather than the book.
> The local `_external/borcherds/03_leech.tex:419--490` is the **holy-construction/Niemeier existence
> proof**, which in its own words "says nothing about the Leech lattice apart from the fact that it
> exists" — vastly more expensive in Lean and not the route taken.
>
> **A previous reconnaissance's shape list was wrong in all three entries.**  It had
> `48 + 97152 + 4096 = 101296`; the correct counts are `1104 = 4·C(24,2)`, `97152 = 759·2⁷` and
> `98304 = 4096·24`, summing to `196560`.  `(±4, 0²³)` has norm `16` and is not minimal, the octad
> vectors carry `2⁷` sign choices not `2⁸`, and the third family is `(∓3, ±1²³)` not `(±1²⁴)`.
>
> **`vertexAlg`'s Golay file is scaffolding, not a contribution.**  `VertexAlg/GroupTheory/Golay.lean`
> (256 lines, 203 code) compiles at our pin in 4.5 s with no live `sorry`, but it contains only
> projective-line preliminaries, `Golay24.Q` and a bijection `Fin 24 ≃ ℙ(F₂₃²)` — **no submodule of
> `(ℤ/2)²⁴`, no weight function, no weight enumerator, no double-evenness, no self-duality**; its own
> docstring lists those as TODO.  It removes essentially none of the work.
>
> **Milestones** (D = definition, F = finite kernel computation, T = theorem; difficulty 1–5):
>
> | id | content | kind | diff |
> | --- | --- | --- | --- |
> | ~~M0~~ | ~~Golay code from the systematic generator matrix `[I₁₂ \| B]`~~ — **DONE** | D | 1 |
> | ~~M1a–d~~ | ~~`card = 4096`; doubly even; minimum weight `8`; weight enumerator `759, 2576, 759, 1`~~ — **DONE** | F | 1 |
> | ~~M1e~~ | ~~self-duality via `G·Gᵀ = 0` and `rank 12`~~ — **DONE** | F | 1 |
> | ~~M2~~ | ~~carrier `A` with `Decidable`, `0 ∈ A`, `8eᵢ ∈ A`~~ — **DONE** | D/F | 1 |
> | ~~M3~~ | ~~structure theorem `IsLeechVec a ↔ IsEvenForm a ∨ IsOddForm a`~~ — **DONE, in a corrected form** | T | 3 |
> | ~~M3b~~ | ~~the index `\|A/8ℤ²⁴\| = 2³⁶`, as `MM.leech_index : [ℤ²⁴ : A] = 2³⁶`~~ — **DONE** | T | 3 |
> | ~~M4a,b~~ | ~~integrality `8 ∣ a·b`; evenness `8 ∣ a·a` and exactness of `normSq`~~ — **DONE** | T | 2 |
> | ~~M5~~ | ~~unimodularity `Λ* = Λ` by the determinant-free congruence argument~~ — **DONE** | T | 3 |
> | ~~M6~~ | ~~**minimum `32` / no roots**~~ — **DONE** | T | **4–5 (the crux)** |
> | ~~M7~~ | ~~kissing number `196560` with the three shapes~~ | T | 3 |
> | ~~M8~~ | ~~packaging, and `dim V_Λ(1) = 24 + #{λ : λ² = 2} = 24`~~ | D/T | 2 | — **DONE**
>
> **M2 + M3 + M3b are LANDED**, split into `Definitions/MMLeech.lean` (1018 lines: carrier and
> structure theorem) and `Definitions/MMLeechIndex.lean` (457 lines: the index), 0
> `sorry`/`axiom`/`native_decide`, ~3 s to build because it deliberately contains **no
> `decide +kernel`**, unlike `MMGolay`.  `MM.isLeechVec_iff : IsLeechVec a ↔ IsEvenForm a ∨ IsOddForm a`,
> with `IsEvenForm a := ∃ d t, Golay d ∧ Even (Σt) ∧ a = 2·lift d + 4t` and the odd form with
> `Odd (Σt)` and the `1 +`; plus closure under addition and negation and `8ℤ²⁴ ⊆ A`.  Guarded in
> `FinalCheck.lean`.
>
> **M3's recorded shape was WRONG and the work corrected it.**  The reconnaissance said
> "`a = x₀ + 2(d + 2t)` with `t ∈ D₂₄`", i.e. no parity condition on `t`.  Condition (ii)
> `Σa ≡ 4a₀ (mod 8)` forces **`Σt` even in the even branch and odd in the odd branch**, and the
> report's literal `x₀ + 2(d + 2t)` with `Σt` even has `Σa = 0` while `4a₀ = 4` in `ZMod 8`, so it is
> **never** in `A`.  The coset statement survives; the literal form does not.  (Equivalently the odd
> coset is `(x₀ − 4e₀) + 2C + 4D₂₄` with `Σt` even — recorded in the docstring as prose, not as a
> theorem.)
>
> **M3b, the index, is LANDED**: `MM.leech_index : [ℤ²⁴ : A] = 2³⁶`, with `MM.relIndex_sm8_AHat`
> (`|A / 8ℤ²⁴| = 2³⁶`), `MM.card_quotient_AHat` (the order of `ℤ²⁴/A`) and `MM.card_image_leech` (the
> count itself) as equivalent forms.  A residue class of `A` mod `8ℤ²⁴` is exactly
> `key d τ = Στ + 2·lift d + 4τ` with `d ∈ C` and `τ : Idx → ZMod 2` — the `Στ` term is the parity
> correction the mod-8 congruence forces, by M3 — so `key` injective gives `4096 · 2²⁴ = 2³⁶` classes
> (`MM.key_injective_pair`), and `relIndex_mul_index` applied to `8ℤ²⁴ ≤ A` against
> `index (8ℤ²⁴) = 8²⁴` (`MM.index_sm8`, from `AddSubgroup.index_range_nsmul`) gives
> `2³⁶ · [ℤ²⁴ : A] = 2⁷²`.  `Probe/leech_verify.py` had already computed the same number from the
> definition, independently of Lean.
>
> **The previously recorded obstruction was WRONG, and the correction is worth keeping.**  The record
> said "`key_injective` times out deterministically at `whnf` … because `omega` is asked to split
> `e + 2x + 4u = e' + 2x' + 4u'` over `ZMod 2`-derived integers", and that the only fix was to redo the
> count over `Nat` masks.  In fact the attempt in `Probe/LeechIndex.lean` had **ten errors**, of which
> the `whnf` timeout was one: `eq_of_lift_eq` (lines 110/116) was broken from the start, so
> `key_injective` only *elaborated* on top of an error-recovered `sorryAx` dependency — the evidence file
> `Probe/LpAx1.lean` reproduces it: run `tools/build.sh Probe/LpAx1.lean` and its last
> line is `'MM.Attempt2.key_injective' depends on axioms: [propext, sorryAx, Classical.choice,
> Quot.sound]`.  `MM.key_injective` itself is fine and was never the problem; the timeout
> comes from *applying* a `Function.Injective` statement whose implicit pair-argument is stuck behind
> `Prod.fst`/`Prod.snd` — the unifier then reduces `key`, `keyInt` and the `ZMod 8` casts.  The fix is
> `MM.key_injective_pair`, with the four arguments as explicit binders.  Two smaller traps: the
> `rw [zmod_int_eq_iff_dvd_sub …]` pattern does not match the goal of `key_of_even`/`key_of_odd` (the
> sides come out swapped; use `exact <Iff>.mpr <witness>`), and `key_mem`'s final goals need `key`
> unfolded, not just `keyInt`.  Nothing needed `Nat` masks.
>
> **THE REPORTED OBSTRUCTION FOR M3b WAS WRONG IN THREE WAYS, and this is the fifth time in this
> project that a recorded blocker, once checked, was not what it claimed.**  Keeping the corrections
> is the point — the rule "a reported blocker is a hypothesis" keeps earning its place:
> 1. **The file had ten errors**, the first at lines 110/116, not the single `whnf` timeout at line
>    241 that was reported.  Because that earlier proof was error-recovered, **`key_injective` only
>    ever *elaborated* on a `sorryAx` dependency** — `Probe/LpAx1.lean` still reproduces
>    `'…key_injective' depends on axioms: [propext, sorryAx, Classical.choice, Quot.sound]`.  So the
>    claim that it "now compiles" was an artefact of error recovery, and **the only thing that
>    detects this is `#print axioms`**: a file can compile, and a theorem can exist, while depending
>    on an axiom nobody declared.  This is the sharpest argument in the repository for why that check
>    is not optional.
> 2. **`key_of_even` had no timeout at all.**  It was a plain `rw` pattern-match failure:
>    `zmod_int_eq_iff_dvd_sub 8 A B` instantiates with its two sides swapped against a goal of the
>    form `↑A = ↑B`.  Fixed by `exact (…).mpr ⟨k, by omega⟩`, with no `rw`.
> 3. **The `whnf` timeout was neither `ZMod 2` instance search nor `omega` — that was the
>    dispatcher's own diagnosis, and it was wrong**, as was the fix recorded from it ("redo the count
>    over `Nat` masks").  It fires when the `Function.Injective` statement `key_injective` is
>    *applied* to a hypothesis not syntactically of the form `key d τ = key d' τ'`: instantiating its
>    implicit pair argument makes the unifier compare `key (Prod.fst ?a) (Prod.snd ?a)` with
>    `key d τ`, reducing `key`, `keyInt` and the `ZMod 8` casts.  Fixed by `MM.key_injective_pair`
>    (explicit binders) plus a bijection whose codomain is the plain function type.  **No `Nat` masks
>    were needed.**
>
> **M6's arithmetic is now verified and recorded, because it is easy to get wrong.**  Writing the
> M3 shapes with `b := d + 2t` (so the vector is `2b` in the even case and `1 + 2b` in the odd case,
> `|d|` the codeword weight in `{0,8,12,16,24}`):
>
> * **Even case:** `a·a = 4·(b·b)` and `b·b = |d| + 4S + 4Q` with `S := Σ_{j ∈ supp d} t_j`,
>   `Q := Σ_j t_j² ≥ 0`.  So `b·b ≤ 7` forces `|d| ≤ 7`, hence **`|d| = 0`**; then `b = 2t` gives
>   `b·b = 4Q ≤ 7`, so `Q ≤ 1`, and `Σt` even rules out `Q = 1`.  Hence **`a = 0`** — the even case
>   needs no case analysis at all.
> * **Odd case:** `a·a = 24 + 4·(Σ_j b_j) + 4·(b·b)`, so `a·a ≥ 32 ⟺ Σ ≤ …` where
>   `Σ := Σ_j b_j + b·b` must be `≥ 2`.  If `|t_j| ≥ 2` then `b_j² ≥ 9` (inside `supp d`) or `≥ 16`
>   (outside), so `b·b > 6`; hence under `b·b ≤ 6` we have `t_j ∈ {-1,0,1}`, and then `Q = 0` forces
>   `t = 0`, contradicting `Σt` odd.  **Exhaustive check over `|d| ∈ {0,8,12,16,24}` and `Σt` odd:
>   the minimum of `Σ` is exactly `2`, attained only at `|d| = 0` with `t = -e_j`** (one coordinate
>   `-1`), giving `a = 1 - 4e_j`, `a·a = 32`.  For `|d| = 8, 12, 16, 24` the minima are
>   `64, 96, 128, 192`, a large margin — only `|d| = 0` needs care.
>
> **Two corrections were needed to get here:** the reconnaissance's recorded case split for M6 said "`b·b ≤ 8 ⟹ |d| ≤ 8 ⟹ |d| ∈ {0,8}`, both cases
> elementary", which is loose (the true forcing is `|d| = 0` in the even case); and the dispatcher's
> own first bound for the odd case, `Q ≤ 3`, was **wrong** and had to be replaced by the `Q ∈ {0,1,≥2}`
> split above.  This is the sixth correction of a recorded route, split or bound on the Leech
> milestones alone.
>
> **M4 and M6 are LANDED.**
>
> * **M4** — `Definitions/MMLeechForm.lean` (301 lines): `MM.leech_sum_mul_dvd : 8 ∣ ∑ aⱼbⱼ`,
>   `MM.leech_sq_dvd : 8 ∣ ∑ aⱼ²`, and the exact division `MM.normSq_spec : 8 * normSq a = ∑ aⱼ²` —
>   so `(x,y) = (Σxᵢyᵢ)/8` is integral on `A`.
>   **The input M4a actually needs is "Golay is doubly even AND closed under addition"** — `4 ∣ wt`
>   applied to `d`, `e` **and** `d + e` (the last through `MM.two_dvd_wt_mul`, which supplies
>   "`|c ∩ c'|` even"); `2 ∣ wt` alone would not suffice.  **And M3's parity correction is equally
>   load-bearing**: the terms `4·ca·S` and `4·cb·T` are each `4 mod 8` in the odd branch and cancel
>   only via `S ≡ cb`, `T ≡ ca (mod 2)`.  So integrality is an **independent confirmation that the
>   corrected M3 shape is right** — the reconnaissance's `x₀ + 2(d+2t)` with `Σt` even gives `4 mod 8`.
>   Recorded precision: the "`4ℤ²⁴` direction" of `A` is generated by `4·lift d` and `8·eᵢ`, **not** by
>   `4·eᵢ` — indeed `4eᵢ ∉ A` (coordinate sum `4` but `4a₀ = 16 ≡ 0 mod 8`).
> * **M6** — `Definitions/MMLeechMinNorm.lean` (455 lines):
>   `MM.leech_min_norm : IsLeechVec a → a ≠ 0 → 32 ≤ ∑ aⱼ²`, with `MM.leech_min_norm_attained`
>   exhibiting the minimiser.  So `Λ` is **rootless** with minimum norm `4`, which is the arithmetic
>   that forces the moonshine module to use a rootless lattice.
>   **The odd branch is proved by a 2-line argument that supersedes both the reconnaissance's split and
>   the dispatcher's replacement for it.**  With `b := d + 2t` and `Z := Σⱼ (tⱼ + dⱼ)(1 + 2tⱼ)`:
>   `Σⱼ bⱼ + b·b = 2Z` **exactly** (so `a·a = 24 + 8Z` and the goal is `Z ≥ 1`); `Z ≥ 0` **pointwise
>   for every integer `tⱼ`** (the two factors always share a sign — so no bound on `|tⱼ|`, no support
>   bound, no `b·b ≤ 6` hypothesis is needed); and `Z` is **odd** because `Z ≡ Σt + wt d (mod 2)` with
>   `Σt` odd and `4 ∣ wt d`.  Hence `Z ≥ 1` and `a·a ≥ 32`.  The odd branch's only Golay input is
>   `4 ∣ wt d`; the weight set `{0,8,12,16,24}` is needed only in the even branch, where
>   `2 ∣ Σtⱼ² − Σtⱼ` makes `Q` have the parity of `Σt` and so rules out `Q = 1` without support counting.
>   **Minimiser:** `a = x₀ − 4eⱼ` (one coordinate `−3`, the rest `+1`, `a·a = 32`); `t = +eⱼ` gives
>   `a·a = 48`, so the **sign matters** — the substance of the dispatcher's correction, which was
>   right, though its case analysis was not needed.
>
> **M5 is LANDED** — `Definitions/MMLeechUnimodular.lean` (546 lines, 0 `sorry`/`axiom`/`native_decide`,
> 2.8 s to build, no enumeration): `MM.isLeechVec_iff_eight_dvd : (∀ a ∈ A, 8 ∣ ∑ aⱼyⱼ) ↔ y ∈ A`;
> `MM.leech_unimodular` and `MM.leech_dual_eq_eighth`, stating the dual of `A` as `A* = (1/8)A` — with
> `x = y/√8`, `λ = a/√8` one has `⟨x,λ⟩ = ⟨y,a⟩/8`, so this is **literally `Λ* = Λ`**.
>
> **The unimodularity statement I proposed in the task brief was FALSE, and the proof corrected it.**
> I suggested "`x` integral against every `a ∈ A` ⟹ `x` has integral coordinates and lies in `A`".  The
> counterexample is `x = x₀/4 = (1/4,…,1/4)`: it pairs integrally against every `a ∈ A` because
> `Σⱼ aⱼ ∈ 4ℤ` (it is `0` or `4` mod `8`), yet `x ∉ A`.  The correct unscaled statement is `8A* = A`,
> i.e. `A* = (1/8)A` — the scaling is load-bearing, exactly as it was for the definition of `A` itself
> (where `1/√8` was essential and two memory-based attempts failed for want of it).  **This is the
> seventh recorded route or statement on these milestones that the work corrected.**
>
> The four steps of the recorded route all survived, with one normalization correction and one
> statement correction: `4(eᵢ − e_j) ∈ A` gives `4(xᵢ − x_j) ∈ ℤ` (**not** `xᵢ ≡ x_j (2)` for the
> rational `x` — that was the recorded route's imprecision); `2c ∈ A` gives `4 ∣ Σ_{i∈c} yᵢ`; the class
> words land in `C^⊥ = C` via `MM.golay_self_dual`; and the odd generator is **`x₀ − 4e₀`**, not `x₀`
> (the brief's tentative `x₀ = 1` is **not** in `A`, since `24 ≢ 4 mod 8`).  An independent numeric
> cross-check (`Probe/m5_dual_check.py`) confirms the four generator families really generate `A`
> (`[ℤ²⁴ : span] = 2³⁶`) and tests `x₀/4`, `x₀ ∉ A`, `2x₀ ∈ A`.
>
> **Evenness is LANDED too** — `Definitions/MMLeechEven.lean` (215 lines, 1.6 s):
> `MM.leech_sq_dvd_sixteen : IsLeechVec a → 16 ∣ ∑ aⱼ²` and `MM.two_dvd_normSq`, so every norm is an
> **even** integer and `Λ` is an even lattice.  **M4b's recorded input list was incomplete:** its
> docstring said the sharpening follows from the same expansion with `(lift d j)² = lift d j` and
> `4 ∣ wt d`, which is complete for the **even** branch, but the **odd** branch also consumes
> `Odd (∑t)`.  With `∑t` even one gets `24 + 8·wt d ≡ 8 (mod 16)`, so `2 ∤ normSq` — witness
> `a = x₀`, where `∑aⱼ² = 24` and `normSq = 3`.  **So evenness follows from M3's parity correction,
> not from the Golay code alone** — the same conclusion M4a's integrality and M6's minimum each forced
> independently, making this the third such confirmation.  The stale docstring is corrected in place
> (including a `30000` that should have been `20000`, the count the checked-in script actually uses).
>
> **M7's parametrisation is found and verified, and the three families are now precise.**  The
> reconnaissance's three *numbers* are all correct; its *prose* was imprecise in one place.  Writing
> `W := wt d`, and using the M3 shapes:
>
> | family | count | parametrisation | why |
> | --- | --- | --- | --- |
> | `(4,4)` | `1104 = 4·C(24,2)` | even branch, `W = 0`: `a = 4t` with `Σtⱼ² = 2`, so `t = ±eᵢ ± eⱼ`, `i ≠ j` | unordered pair `{i,j}` plus a sign per element |
> | `(2⁸)` | `97152 = 759·2⁷` | even branch, `W = 8`: `S + Q = 0` pointwise forces `t_k ∈ {0,−1}` on `supp d` and `0` off it, so `a = 2·1_d − 4·1_u` with `u ⊆ d` | **M3's parity condition `Even (Σt)` is exactly `\|u\|` even**, and an 8-set has `2⁷` even subsets |
> | `(∓3, ±1²³)` | `98304 = 4096·24` | odd branch: `a·a = 24 + 8Z` with `Z = Σ_k (t_k + d_k)(1 + 2t_k) ≥ 0` pointwise, so `a·a = 32 ⟺ Z = 1`, i.e. exactly one summand is `1` | data is `(codeword, coordinate)`; the two ways a summand can be `1` give `−3` and `+3`, and `Σt = −wt d + 2d_{j₀} − 1` is **automatically odd**, so the odd parity hypothesis is free here |
>
> `1104 + 97152 + 98304 = 196560`.  **The dispatcher re-derived all three independently and checked
> family 2 exhaustively**: over a fixed octad, exactly the `128 = 2⁷` even subsets `u` are admissible
> and every one of them gives `a·a = 32`.  The bijection `u ↦ u Δ {k₀}` (even ↔ odd subsets) is what
> makes `2⁷` rather than `2⁸`, so the count is **a consequence of M3's parity correction** — the
> **fourth** place that correction is load-bearing, after M4a's integrality, M6's minimum and
> `MMLeechEven`'s evenness (where, without it, `a = x₀` gives `normSq = 3`).
>
> **A `Fintype`/`DecidablePred` trap measured on this file**: instance search does **not** unfold the
> `Golay` `abbrev` under `DecidablePred`, so `Fintype {d // Golay d}` and `Fintype {d // Golay d ∧
> wt d = 8}` are not synthesizable; they need an explicit `DecidablePred` instance for the octads and
> an `inferInstanceAs`-transported `Fintype` for the codewords — the sharper form of the milder note
> already recorded under M0/M1.
>
> **M7 is LANDED** — `Definitions/MMLeechKissing.lean` (1373 lines, 0 `sorry`/`axiom`/`native_decide`,
> 2.5 s to build, no enumeration): **88 declarations, every axiom footprint a subset of the three
> standard axioms** (77 exactly, 9 without choice, 2 with none at all), and
> * `MM.leech_kissing_number : {a | IsLeechVec a ∧ ∑aⱼ² = 32}.ncard = 196560` — the classical Leech
>   kissing number;
> * `MM.leech_min_iff_shape`, the classification of the minimal vectors;
> * `MM.leech_shape44_ncard = 1104`, `MM.leech_shape28_ncard = 97152`, `MM.leech_shape3_ncard = 98304`.
>
> The three families' **intrinsic** shape predicates are worth recording, since they are what the
> classification actually says: `IsShape44` (two coordinates `±4`, the rest `0`), `IsShape28`
> (coordinates in `{0,±2}`, the `+2`-support a Golay octad, and an **even** number of `−2`s), and
> `IsShape3` (coordinates in `{±1,±3}` with a **unique** coordinate of absolute value `3`).  Each
> parametrisation is proved injective, in the carrier, and of squared length `32`, and the three are
> pairwise disjoint.
>
> **M8 is LANDED, and the Leech sequence M0--M8 is CLOSED.**
> `Definitions/MMLeechLattice.lean` (661 lines, 0 `sorry`/`axiom`/`native_decide`, 1.8 s):
> `structure MM.LeechLattice` with fields `ASub`, `ASub_eq`, `rank_eq`, `index_eq`, `integral`, `even`,
> `selfDual`, `posDef`, `noRoots` — **all five properties filled, none assumed** — inhabited by
> `MM.leech_lattice_isLeech`.  Plus `MM.leech_rank : Module.finrank ℚ QSpan = 24` (the earlier files
> had only the index), the pruned enumerator `MM.leechBox` with its pruning-correctness lemma,
> `MM.leechThetaCoeff` with `MM.leechThetaCoeff_zero`, and the moonshine consequence.
>
> **Two deliberate honesties.**  (i) The `selfDual` field is `A* = (1/8)A`, the true form — the
> docstring states that the unscaled `A* = A` is false, and **no `24 × 24` Gram determinant is
> computed**: `det = 1` is the field `index_eq : [ℤ²⁴ : A] = 2³⁶`, since `[ℤ²⁴ : A]² = 8²⁴`.
> (ii) **`V_Λ` is not constructed anywhere in this repository**, so the moonshine consequence is
> stated as the arithmetic the future construction consumes — `MM.leechWeightOneDim := 24 +
> MM.leechCount 2` with `MM.leech_weight_one_dim : MM.leechWeightOneDim = 24` and
> `MM.leechCount_two : leechCount 2 = 0` from M6 — and **not** as a `finrank` of an object that does
> not exist.
>
> **A name collision the dispatcher had to fix at merge time**: the file had mirrored `MM.E8`'s
> vocabulary too faithfully and used `MM.Candidate`, which `Definitions/MMLevelTwo.lean` already
> declares, so `FinalCheck.lean` failed with `environment already contains 'MM.Candidate.mk.injEq'`.
> Renamed to `MM.LeechCandidate` / `MM.IsLeechLattice`; the E8 names are untouched.  **Mirroring a
> sibling module's vocabulary is fine for the shape and dangerous for the names.**
>
> **What the closed sequence says**: `Λ = 2^{-3/2}·A` is an **even integral unimodular rank-24 lattice
> with no roots and kissing number `196560`** — the Leech lattice — with every one of those words a
> named, guarded theorem.  **What it does not say**: nothing about `V_Λ`, which is not built.  The
> remaining multi-year items are unchanged: the `c = 1 → c = 24` tensor layer (which exists nowhere)
> and the no-ghost theorem.
>
> **Only M1a–M1e are finite kernel computations.**  M3–M7 are elementary but are congruence and
> sum-of-squares **case analyses, not enumerations**: `A/8ℤ²⁴` has `2³⁶` elements, and this
> repository's own rank-8 experience is the warning (`thetaCoeff 1 = 240` and even `thetaCoeff 0 = 1`
> did **not** finish in ~18 min when task D-d re-measured them; the earlier "11 s / 497 s" figures did
> not reproduce, and neither did the suggested `countP`/`Bool`-predicate rewrite — the pruned
> enumeration `boxAux` is what does not scale, not the predicate).  Brute-force lattice enumeration is
> out; the M6 case split actually used is the one recorded above, and the numeric script enumerates
> exactly those cases, so a subagent can check its split against machine-verified lists.
>
> **M0 + M1a--M1e are LANDED** in `Definitions/MMGolay.lean` (746 lines, 58 theorems, 0 `sorry`,
> 0 `axiom`, 0 `native_decide`; every declaration's `#print axioms` is the three standard axioms
> except `msgOf_xor`, which is the strict subset `[propext, Quot.sound]` because it never uses
> choice).  Guarded in `FinalCheck.lean`.  Measured: the file takes **3 m 25 s** to build and
> `FinalCheck.lean` **25 s** with it imported.
>
> **Two claims in the brief for that task were refuted by the work, and both are recorded rather
> than smoothed over.**
> * **"doubly even (indeed by 8)" is FALSE.**  The extended Golay code has **2576 words of weight
>   `12`**, so `8 ∣ wt` fails.  The sharp true statement is `4 ∣ wt` (`golay_doubly_even`), with the
>   exact weight set `{0, 8, 12, 16, 24}` (`golay_weights`).
> * **The twelve generator masks' provenance is NOT formalized.**  They are literals produced by
>   `Probe/leech_verify.py` from the length-23 quadratic-residue code plus a parity bit; what is
>   re-proved here is that these twelve words generate a `[24,12,8]` doubly-even self-dual code,
>   agree with the parity-block enumeration on all `4096` messages (`codeWord_eq_encLin`), and
>   contain the all-ones word.  Formalizing the QR-code provenance is not part of M0/M1.
>
> **Two NEW traps, both measured, both of which M2 onward must avoid.**
> * **`ZMod 2` division-ring instance paths HANG the elaborator.**  `LinearMap.finrank_range_add_finrank_ker`
>   and `Submodule.eq_of_le_of_finrank_le` are stated for `[DivisionRing K]`; at `K = ZMod 2` the
>   elaborator cannot reconcile `CommRing.toCommSemiring.toSemiring` with
>   `DivisionRing.toDivisionSemiring.toSemiring` and does not terminate — deterministic whnf timeout
>   at 200k heartbeats, and **over 300 s wall clock even with `maxHeartbeats 8000000`**.  Rank and
>   dimension arguments over `ZMod 2` must go through `finrank_span_eq_card`,
>   `Submodule.card_eq_card_quotient_mul_card` and `LinearMap.quotKerEquivRange` instead.
>   `Set.eq_of_subset_of_ncard_le` is also dangerous there (its `toFinite_tac` default plus
>   `Nat.card_coe_set_eq` rewrites hung the elaborator).
> * **One big `decide +kernel` can OOM the machine.**  The `4096 × 12` bridge check peaks above
>   `7 GB` RSS and was **OOM-killed** (`journalctl -k`: `anon-rss:7255024kB`); split into `8` blocks
>   of `512` it peaks at `~5.7 GB`.  With `~7 GB` free the build is comfortable, so **do not run
>   these checks concurrently with another heavy build.**
> * A third, milder one: instance search does **not** find `Fintype {w // Golay w}` (application
>   form) even with a `Decidable (Golay w)` instance; `Fintype {w // inGolay w = true}` and
>   `{w // w ∈ Golay}` do work, so all counting statements use the explicit form.
>
> **Measured kernel costs** so M2 onward can budget: `golay_low_bits` (4096×12 bits) ≈ 21 s,
> `golay_weights` ≈ 25 s, `golay_weight_counts` ≈ 24 s, the `bridgeHigh_0..7` blocks ≈ 17 s each
> (~136 s total).  Also noted: `inGolay` costs a `4096`-candidate search per kernel evaluation, which
> M2a's carrier will pay per class word — the Leech design already accepts this, but a cheaper
> decision procedure (extract the low 12 bits, `codeMask n % 4096 = n`) is available and not done.
>
> **Measured traps a subagent must not re-discover** (from `Probe/LeechRecon.lean`, which compiles
> in 1 m 27 s with seven proved declarations, all printing the three standard axioms):
> * enumerating a **function type** such as `Fin 12 → ZMod 2` blows up in `piFinset` `Nodup`
>   bookkeeping — enumerate `Nat` masks over `Finset.range 4096` instead;
> * plain `decide` exceeds the heartbeat limit; **`decide +kernel`** (the device already used at
>   `Definitions/MMLevelTwo.lean:102`) is what works;
> * instance search neither unfolds a plain `def` nor sees through `w ∈ Golay`: make the code an
>   `abbrev` with a `Bool` membership test and state the carrier condition as
>   `inGolay (cls a r) = true`; index the four class words by `Fin 4`;
> * **no `native_decide` is needed** — the 4096-word checks are affordable in the kernel (75 s).
>
> **A discipline note, kept for the record:** M8's guarded moonshine statement depends on `noRoots`,
> so **M6 had to be discharged before any guarded declaration could cite it**; the "no roots"
> hypothesis stayed explicit until then, exactly as the paper's `c(0) = 0 ⟹ no roots` argument carries
> it.  (Discharged: see M6 above.)

### PHASE 0 DECIDED, AND PHASE 1's FIRST INCREMENT LANDED (both measured)

> **Phase 0: vendor the `vertexAlg` axiom core.**  Both port measurements are in.
>
> * `vertexAlg` (commit `bd8adbb`, tag `v4.33.1`): **35/35 modules compile against our pin, 0 errors,
>   0 warnings.**  The reason is decisive and measured rather than assumed: its Mathlib pin is
>   `0df444a3`, ours is `db584cd`, and **`db584cd` is its direct parent** — distance **1 commit**,
>   touching only `lean-toolchain` (`v4.33.0` → `v4.33.1`).  The Mathlib source is identical, so the
>   error-classification table is empty *by construction*, not by luck.
> * **Vendored**: the minimal compiling core, **9 files / 5507 lines**, byte-identical to upstream.
>   `tools/build.sh` gained a `--vendor` mode, because `lean` resolves `VertexAlg.*` on the **module**
>   path while the compile loop derives outputs from the **source** path — listing them as ordinary
>   files writes oleans where no `VertexAlg.*` import can find them.  Verified: 9/9 OK and
>   `import VertexAlg.VertexBasic.Borcherds` works from an MM module.
> * **Two corrections to the earlier reconnaissance, both by compiling.**  (i) The **locality half of
>   the axiom equivalence is NOT proved**: `locality_if_Borcherds_sums_2_3_eq`,
>   `Borcherds_sums_2_3_eq_if_locality`, `borcherdsId_at_large_t_iff_locality`,
>   `skew_symmetry_iff_Borcherds_at_zero` are inside comment blocks with `sorry` bodies, and
>   `def IsLocal` is commented out.  (ii) **There are no models at all**: 6,414 of 10,772 lines are
>   live and there are 714 live declarations, but **no instance of `VertexAlgebra` or
>   `VertexAlgebra1` exists anywhere upstream**, and `Affine.lean`, `Lattice.lean`,
>   `ChevalleyEilenberg.lean`, `Lie/Basic.lean` are 100 % doc-comment.  So what is formalized is the
>   **interface**, not vertex algebras; `V_L`, `V_{II^{1,1}}` and `V^♮` are all still to be built.
>   See `vendor/vertexAlg/README.md`.  Upstream tracks **no LICENSE file** despite Apache-2.0
>   headers — recorded, not worked around.
>
> **`VirasoroProject` is the real port, and it is small — but it does not contain the moonshine
> layer.**  At our pin `main` (`555a9096`) gives **47 independent errors in 6 files**, blocking 15 of
> 32 modules; but upstream branch **`bump-202606`** (`e3e08a3b`, same mathematics, no `sorry`) already
> did most of the work and leaves only **21 errors in 4 files**.  Porting those 4 files (~50 changed
> lines, two of them one-liners) reaches **25 of 32 modules green**, measured.  Realistic total:
> **5 files, ~60--100 lines, 2--4 hours, no mathematical statement changed**.  The drift is
> mechanical: `LieRing.ofAssociativeRing` demoted to file-local, the Lean core split of
> `nsmul`/`zsmul` into `NSMul`/`ZSMul` parents, `Set`/`DecidablePred` reducibility, and
> `UniversalEnvelopingAlgebra` re-based from `RingQuot` to `RingCon`.  Bottleneck file
> `LieCohomologySmallDegree.lean`.  **And it contains no `TensorProduct` of modules, no coalgebra,
> no lattice/VOA/vertex machinery — zero hits in both trees** — so `V ⊗ V_{II^{1,1}}` is new
> mathematics at any pin, not a port.
>
> **Phase 1's first increment landed: `Definitions/MMGenusZeroArith.lean`** (224 lines,
> Mathlib-only, no FLT import, 0 `sorry`/`axiom`/`native_decide`) — the packaged form of the
> `genusZero_level` / `genusFormula_eleven` result measured in "M1's COST WAS MIS-STATED" above, both
> guarded in `FinalCheck.lean`.  **It is arithmetic about a definition and asserts nothing about
> `Γ₀(N)`**; the identification "this formula = the genus of `X₀(N)`" remains the open geometric
> content.  Two measured semantic traps are recorded there: `ψ` must be
> `∑ d ∈ N.divisors with Squarefree d, N / d` (the tempting `if Squarefree d then d else 0` is *not*
> Dedekind psi — at `N = 4` it gives `3` instead of `6`, so the formula returns `-1/4`), and the
> completeness half (that no other `N` has genus zero) is checked only numerically, for `N ≤ 300`,
> and is **not** formalized.

### Phasing (each phase ends in a compiling, `sorry`-free increment)

**Phase 1 — the modular half of the Conway--Norton table (tractable; no vertex algebras).**
Deliver: `Γ₀(N)` as a subgroup of `GL(2, ℝ)`, the genus-zero list as a *proved* statement for the 15
Conway--Norton levels, and the bridge to `MM.IsAnalyticNormalizedHauptmodul`.  The genus numbers come
from FLT; the bridge is the open question (see the `M1` entry).  Discharges the *modular* part of
assumed input 4.

**Phase 2 — the monster group as a real object.**  Finiteness and order `|M| = 2^46·3^20·5^9·7^6·
11^2·13^3·17·19·23·29·31·41·47·59·71` from the presentation (task S3), then retargeting
`MoonshineModule` to `MM.Monster` (S4), then the character table for section 9's case check (M1').

**Phase 3 — the no-ghost theorem.**  Self-contained and independent of the module construction
(Frenkel--Goddard--Olive / Goddard--Thorn).  This is the item to attack *before* Phase 4, because it
is a finite, well-stated theorem rather than an open-ended construction.

**Phase 4 — the moonshine module itself.**  Lattice vertex algebras `V_Λ` for Λ even unimodular,
the tower construction of `V^♮` (`V_Λ⁺`, the orbifold, the `σ`-twisted module), the monster action,
and the graded character `j - 744`.  **This is the multi-year item** and it is the only one where the
plan cannot be given as a finite task list today; it needs its own reconnaissance before it can be
phased, which is dispatched as part of Phase 1's work.

### Reporting rule for this campaign

Each phase's increment must compile (`tools/build.sh`, exit 0), add no `sorry`/`axiom`/`native_decide`,
and land with the README/ROADMAP updated.  A phase that turns out to be mis-scoped is recorded as
such rather than quietly dropped — the third defect of the `IsHauptmodul` family is the reason that
rule exists.

## Stream M — the Conway--Norton table (removes assumed input 4)

> **M1-L1h IS DONE (2026-09-13): the level-one integrality input `hq` is PROVED.**  Two files,
> `Definitions/MMLevelOneJCoeffs.lean` (582 lines) and `Definitions/MMLevelOneHq.lean` (507 lines), both
> in `FinalCheck.lean` with ten `#print axioms` guards, each exactly
> `[propext, Classical.choice, Quot.sound]`: `MM.levelOneA : HahnSeries ℤ ℤ` satisfies
> `MM.levelOneA_isNormalized` and **`MM.levelOneA_hasQExpansion : HasQExpansion ((levelOneJ - 744) - qInv)
> levelOneA`**, and `MM.levelOne_hauptmodul_of_orbitSeparation_discharged` /
> `…isAnalyticNormalizedHauptmodul_of_orbitSeparation_discharged` restate the two conditional theorems of
> `Definitions/MMLevelOneCusp.lean` with that hypothesis discharged — **still taking
> `MM.LevelOneOrbitSeparation` explicitly**.  `MMLevelOneCusp.lean` itself is deliberately unmodified, so
> its own theorems still carry `hq`; the proved versions live in the new file.
>
> **Why it took five attempts, recorded because the lesson is general: the first four were chasing an
> IMPOSSIBLE intermediate.**  `qExpansion 1 MM.qInv = 0` is **not provable**, and not for want of effort:
> `cuspFunction h f = update (f ∘ invQParam h) 0 (limUnder (𝓝[≠] 0) (f ∘ invQParam h))`
> (`Mathlib/Analysis/Complex/Periodic.lean:119`) and `q ↦ q⁻¹` is unbounded near `0`, so its `limUnder` is
> `Classical.epsilon (fun _ : ℂ => False)` — a canonical *arbitrary* element of ℂ — and `qExpansion`'s 0-th
> coefficient **is** that value (`qExpansion_coeff`, `m = 0`).  So the statement is false, not hard, and the
> dispatcher's own briefs asked for it three times.  **The working route never touches it:** expand the
> *analytic* function `(j − 744) − q⁻¹` as a whole (`MM.levelOneCuspBounded`), use
> `qExpansion 1 Δ = X·map P_Z`, do the **division in `ℤ⟦q⟧` before mapping** (`invOfUnit`; `P_Z` has constant
> term 1) and cancel `X`.  Coefficients verified: `coeff 0 = 0`, `coeff 1 = 196884`, `coeff 2 = 21493760` —
> `c(g,0) = 0` being the FLM fact `V_0 = 0` (`MM.DenominatorIdentity.coeff_one`) and `196884 = dim V_1`.
>
> **What this changes, and what it does not.**  Level one's *analytic* story is now complete except for
> orbit separation: invariance, surjectivity, the cusp expansion, the integrality of the coefficients and the
> two-sided `q`-expansion are all theorems.  The **only** remaining input for `MM.IsAnalyticNormalizedHauptmodul`
> at level one is still `MM.LevelOneOrbitSeparation`, which is the valence formula — and the owner has paused
> that.  So this increment does not reopen stream M; it finishes the half that never depended on the pause.
>
> **Dispatcher verification (not the task's report):** oleans deleted, then
> `tools/build.sh Definitions/MMLevelOneJCoeffs.lean Definitions/MMLevelOneHq.lean FinalCheck.lean` →
> three `--- OK ---` lines, exit 0; `forbidden_tokens.py` clean on all three, exit 0; `FinalCheck.lean`
> prints only its pre-existing unguarded `MoonshineConjectureStatement.genusZero_exists` line.
> **Three dispatcher errors from this sub-stream are on record in the files themselves** (the `qExpansion qInv`
> route asked for three times; a wrong "induct instead of using Mathlib's `iter_deriv_inv'`" instruction; and a
> false claim that `invOfUnit_mul` needs a `Field`), plus one library figure the retry found wrong in a
> repository header (`[q²]P_Z` is `252`, not `553176`).

### [paused] M1 — genus zero for the groups in the table — **PAUSED BY THE OWNER 2026-09-13**

> **Owner decision (2026-09-13): stream M1 is paused.**  Asked to choose between funding the
> level-one valence formula (1,500--3,000 lines, no partial credit — see the M1-L1g reconnaissance
> block below, which is the measured case for it), landing only the cheap restatements, taking FLT's
> 606-module algebraic route, or pausing M1 for another stream, the owner chose **pause and move
> elsewhere**.  What that decision means in practice, stated so it is not misread:
> * **No further M1 task is dispatched**; the M1-L1g reconnaissance result stands as evidence, and
>   the valence-formula project is *not* cancelled — it is unstarted and priced.
> * **The level-one integrality half is not M1-blocked and was allowed to finish** (task M1-L1f,
>   accepted 2026-09-13: `MM.qExpansion_levelOneDiscTprod_eq_formal`), because it needs no valence
>   formula.  A follow-on packaging task (level-one `hq`) may complete independently.
> * **The consequence the owner should weigh:** the headline's conclusion still contains
>   `IsHauptmodul` (inside `IsAnalyticNormalizedHauptmodul`), whose orbit-separation conjunct is what
>   the valence formula supplies.  So at the pause, "genus zero" and orbit separation were
>   **load-bearing hypotheses** of `MoonshineConjectureStatement*`, not proved properties — for `𝒮ℒ`
>   as much as for `Γ₀(N)⁺`.  `MM.IsGenusZeroGroup` alone does not carry orbit separation;
>   `MM.IsGenusZeroGroup.exists_isHauptmodul_of_orbitSeparation` takes it as an explicit hypothesis.
>   (**Superseded for level one**: batches 7--9 proved `MM.LevelOneOrbitSeparation` and the level-one
>   Hauptmodul unconditionally — see the HANDOVER blocks.  The pause stands for every other level.)

> **FLT ASSETS SURVEYED (see `FLT-ASSETS.md`, 604 lines, at the repository root).**  A read-only
> reconnaissance of the sibling `fermats-last-theorem` development answered "can it accelerate MM?"
> with evidence, and it **corrected this repository's earlier pessimism**: FLT **does** have a valence
> result, in divisor form — `AlgebraicCurve.Divisor.isPrincipal_of_genus_eq_zero` ("on a genus-0 curve
> every degree-0 divisor is principal", closure **50** modules) — together with genuine order-of-
> vanishing identities at general level (`…sum_ord_jBar_sub_eq_finrank`, `…_eq_dedekindPsi`) and a
> `ComplexPlaceDictionary` whose `pt_eq_pt_iff` turns "inequivalent points" into "distinct places".
> **BUT A VERIFICATION PASS (`FLT-L1-VERIFY.md`, 415 lines) THEN CORRECTED THAT ROUTE, and this is the
> state to work from.**  (a) The survey's flagged caveat was misdirected: `modularFunctionFieldBar N`
> *is by definition* `laurentBaseChange ℚ̄ (modularFunctionFieldFull N)`
> (`Def_ModularCurve_ArithmeticGalois.lean:111`), and FLT itself bridges the two constructions
> (`…laurentBaseChange_…_eq_…FullC`, `genusFF_…FullC_eq_…Bar`); the genuinely open link is
> `genus` vs `genusFF` and the ℚ̄ → ℂ transfer at the `genus` level.  (b) **The route's step 5 is
> invalid as written**: `WLight.levelOne_holFn_eq_polynomial_j` requires `hol : MDiff h` (holomorphic
> on all of `ℍ`), while step 4 concludes that `realize 1 X` has an interior pole at `τ` — the two
> contradict each other, and step 6 evaluates `X` where step 4 says it has a pole.  A repair is sketched
> (`X·(j − j τ)`) and marked unverified.  (c) Costs, measured by walking FLT's import graph with no
> compile: stating the step-2 objects needs **4 modules (1 to compile, ≈5 s)**;
> `Nonempty (ComplexPlaceDictionary 1)` needs **43 (37 to compile)**; making the dictionary usable
> (`pt_eq_pt_iff`) needs **345 (330 to compile)**; the whole route steps 1--3 is **606 modules, 585 to
> compile — realistically 4--15 hours serial**.  (d) Missing pieces not previously listed:
> `Gamma0 1 = ⊤` (Mathlib has `Gamma_one_top` but **no `Gamma0_one`**), the
> `realize 1 (jqModC) = E₄³/Δ` identification, and the `orbitMk` orientation.
> The survey's §4.3 gives a **six-step route to `MM.LevelOneOrbitSeparation`** with every gap named,
> and its honest caveat is that **two objects may differ**: the dictionary targets
> `laurentBaseChange ℂ (modularFunctionFieldFull N)` while the genus theorem is about
> `modularFunctionFieldBar N` — "whether the level-one instances agree is not verified and is the
> first thing to check".  **Where the band is narrow, measured:** FLT has **no `Γ₀(N)⁺`**, and the
> dictionary is typed over `Subgroup SL(2,ℤ)`/`Gamma0 N`, so it cannot be instantiated at `Γ₀(N)⁺` —
> where most of the Conway--Norton table lives.  Cost, measured: FLT's own build directory holds **8
> oleans** while MM's holds 205 (36 of them FLT imports); the decisive closures are 50 modules (the
> divisor theorem) and 345 (the dictionary), a one-off multi-hour compile.  Also recorded there: the
> five theorems with "hauptmodul" in the name are **classical modular relations among `j`-values**, not
> genus-zero/Hauptmodul-function statements, and `Thm_ModularCurve_evalAtJGen_injective` is about the
> *polynomial-ring* map, not about `j` being injective on `ℍ` — two names that would otherwise be
> misread into a brief.

> **Increments landed, level one (`Γ = 𝒮ℒ`) — the only level the sibling repository covers.**
>
> * **M1-L1a** — `Definitions/MMLevelOneHauptmodul.lean` (455 lines): `MM.levelOneJ := E₄³/Δ` on
>   `MM.levelOneGamma := 𝒮ℒ`.  Two of `MM.IsHauptmodul`'s three conjuncts are proved — invariance
>   (`MM.levelOneJ_invariant`) and surjectivity (`MM.levelOneJ_surjective`, from the sibling
>   repository) — and the third, **orbit separation**, is isolated as the named hypothesis
>   `MM.LevelOneOrbitSeparation`.  The route to separation through the sibling's *polynomiality*
>   theorem was proposed, then **refuted as a dead end** with three theorems
>   (`MM.levelOne_polynomial_in_j_constant_on_fibre` and friends, commit `310553a`): every function
>   that theorem certifies is constant on `j`-fibres, so it can never witness a collision.
> * **M1-L1b (this session)** — `Definitions/MMLevelOneDiscUnit.lean` (229 lines) and
>   `Definitions/MMLevelOneCusp.lean` (285 lines): **the cusp expansion is now a theorem**,
>   `MM.levelOneJ_cusp_expansion : IsZeroAtImInfty ((j − 744) − q⁻¹)`, i.e. the classical
>   `j = q⁻¹ + 744 + 196884q + ⋯`.  It rests on the missing coefficient
>   `MM.levelOneDiscUnit_coeff_one : levelOneDiscUnit.coeff 1 = −24`, equivalently
>   `MM.qExpansion_discriminant_coeff_two : (qExpansion 1 Δ).coeff 2 = −24` (from
>   `discriminant_eq_E₄_cube_sub_E₆_sq` plus `E_qExpansion_coeff`), and on the Jacobi product
>   `Δ = 𝕢·∏' n, (1 − eta_q n)^24` with `MM.qExpansion_levelOneDiscTprod : qExpansion 1 P =
>   levelOneDiscUnit`.  A by-product worth reusing: **`MM.isBoundedAtImInfty_div_qParam_pow`** —
>   the first `n` `q`-coefficients of `f` vanishing implies `f/𝕢ⁿ` is bounded at `i∞`.
>   Consequence: `MM.levelOne_hauptmodul_of_orbitSeparation_and_qExpansion` and
>   `MM.levelOne_isAnalyticNormalizedHauptmodul_of_orbitSeparation_and_qExpansion` restate the
>   level-one results with **only two** inputs left — `MM.LevelOneOrbitSeparation` and the
>   integrality input `HasQExpansion ((j−744) − qInv) a`.
> * **Still NOT obtained, with the obstruction named.**  `HasQExpansion` *is* the integrality of the
>   Fourier coefficients of `j − 744 − q⁻¹` (`196884, 21493760, …`), packaged as `HahnSeries ℤ ℤ`.
>   The one missing Lean step is the **analytic-to-formal product comparison**
>   `qExpansion 1 P = PowerSeries.map (Int.castRingHom ℂ) (∏' n, ((1 : ℤ⟦X⟧) − X^(n+1))^24)`:
>   Mathlib has both sides separately but no lemma identifying Taylor coefficients of an infinite
>   product of analytic functions with the formal product's coefficients.  The route around it
>   (`P⁻¹` in `ℤ⟦X⟧` via `PowerSeries.invOfUnit`, E₄³'s coefficients integral by
>   `E_qExpansion_coeff`) is recorded in the footer of `MMLevelOneCusp.lean`.  **It is not called
>   easy and it is not faked.**
> * **Nothing in these files shows `SL₂(ℤ)` has genus zero.**  `MM.HasGenusZero` is the cardinality
>   condition `Nonempty (ℍ/Γ ≃ ℂ)`; see the standing caveat in `MMLevelOneHauptmodul.lean`.

* Deliverable: for each `N` in the Conway--Norton list, a proof of `MM.HasGenusZero` for the
  relevant group (`Γ₀(N)`, `Γ₀(N)⁺`), via an explicit bijection with `OnePoint ℂ`.
* Acceptance: builds, no `sorry`.
* Risk: **very high** — but the recorded reason below was **wrong on two counts** (measured).
  Mathlib has no genus of a modular curve, no Riemann--Roch for modular curves, no modular curve at
  all.  The original paragraph said `fermats-last-theorem` has "~200 files of modular-curve
  infrastructure but also no genus theory"; in fact FLT has **1450 definition modules and 29511
  theorems**, and it **does have genus theory** — `Definitions/Def_AlgebraicCurve_CanonicalDivisor.lean:33`
  defines `genus`, and `Place`, `Divisor`, `LSpace`, `H1`, `indexOfSpecialty`, `HasCanonicalDivisor`
  and a Čech Riemann--Roch family under `Theorems/Thm_AlgebraicCurve_cechRiemannRoch_*` all exist
  (whether unconditional or under an unproved `...Reached`/`...Exists` hypothesis is what the survey
  had to settle).  It is also **importable from this package**: compiling FLT's
  `Definitions/Def_ModularCurve_ProjectiveLine.lean` takes ~5 s, after which MM can `import` it and
  `#check @ModularCurve.IsUnimodularRow`.  The recipe is `tools/build.ps1`'s `LEAN_PATH` **plus the
  FLT root directory** (and `lean -o` does not create directories); FLT's own modules are **not
  built** — only `P2M` has oleans — so any FLT module MM wants must be compiled to `.olean` first.
  `Def_ModularCurve_X0.lean` imports seven stock Mathlib modules and **no FLT-internal module**, so
  the closures are shallow.  The prerequisite sub-project is still: define the compactified modular
  curve `X(Γ)` as a Riemann surface, prove it is compact with finitely many cusps, and state/prove
  the genus formula; the practical first step (M0, below) is the *function field* characterisation of
  genus zero, which avoids Riemann surface theory entirely.

  > **SURVEY RESULT (dispatcher-verified where stated).**  The interface is built and working:
  > `Probe/build-flt-subtree.ps1` resolves FLT's internal imports (`Definitions|Theorems|P2M`),
  > topologically sorts them, compiles incrementally into the right `.olean` mirrors and skips what is
  > current; `Probe/build-mm-with-flt.ps1` wraps MM files that import FLT.  Two mechanisms only
  > measurement reveals: **`lean -o` resolves imports from the output path**, so `P2M.*` must land in
  > FLT's own `.lake/build/lib/lean` (why the first attempt's seven modules "failed"), and on this
  > machine `lean` returns exit code `-1`, not `1`, through MSYS2.  A closure of 8 modular-curve
  > targets is **30 modules**, 9 compiled / 17 skipped / 0 failed.  `Definitions.Def_CohCarrier_Level`
  > is **broken in FLT itself** (`Def_CohCarrier_Level.lean:198`), blocking `Def_ModularCurve_XH` —
  > do not try to fix it.
  >
  > What that buys M1:
  > * **`X₀(N)`'s genus formula is unconditionally proved in characteristic 0**:
  >   `Thm_ModularCurve_genusFF_modularFunctionFieldFullC_eq_genusFormula_algebraicClosure`, plus
  >   `CuspForm.finrank_gamma0_weight_two_eq_genusFormula (N) [NeZero N]`.  So the *genus computation*
  >   half of M1 drops from **very high risk to low**.
  > * `genusZeroLevels := [1,2,3,4,5,6,7,8,9,10,12,13,16,18,25]` (the genus-0 list for `Γ₀(N)`) is
  >   already computed at `P2M/Sol/S_ModularCurve_genusFormula_isNat.lean:957`.  Measured: neither
  >   `decide` nor `norm_num` can recompute it (`genusFormula` uses `noncomputable def`, `Nat.card`
  >   over `ZMod`, `totient`, `dedekindPsi`), so that 2297-line file was necessary — **refuted later
  >   for the arithmetic half** by `Probe/ProbeArithFull.lean` (140 lines, Mathlib only); see
  >   "M1's COST WAS MIS-STATED" above.
  > * **The other half does not drop at all.**  FLT has **no** "genus 0 ⟹ single generator /
  >   `≅ RatFunc`" theorem, and **no algebraic-to-analytic bridge**: FLT's genus is that of an
  >   algebraic function field, while MM's `HasGenusZero` is a statement about `ℍ/Γ`.  Level 1 is the
  >   only precedent (`WLight.levelOne_hauptmodul_package`, which has `j_surjective`).  `Γ₀(N)⁺` —
  >   most of the Conway--Norton table — is unexplored.
  > * **Important negative:** `FunctionFieldGeneration`
  >   (`Thm_ModularCurve_functionFieldGeneration.lean:8`) holds **for all `N`** and does not mention
  >   genus, so it is **not** a genus-zero criterion.  Do not use it as one.
  > * Cost reality: one genus theorem's closure is **1115 modules** (P2M 511 + Theorems 510 +
  >   Definitions 94), dragging in `EMD`/`ModuliPoint`/elliptic curves/Galois representations.

> **M1-L1g reconnaissance: `MM.LevelOneOrbitSeparation` is NOT provable in this environment, and the
> reason is one missing theorem.**  (Dispatcher-dispatched recon task; the dispatch report is at
> `Probe/ORBIT_SEPARATION_RECON.md` with probes `Probe/ProbeM1L1g{A..E}.lean` — **scratch, not
> committed**.  (This note was written by the reconnaissance task itself; the dispatcher has read the
> report and the probes, but has **not independently re-run** the compiled negatives it quotes — they
> are the task's evidence, not the dispatcher's.)
>
> **The single decisive gap:** nothing in Mathlib or `fermats-last-theorem` connects *"a modular form
> vanishes at an interior point `τ ∈ ℍ`"* to *"its `q`-expansion order at the cusp is high"*.  That
> link is the level-one **valence formula**, absent from both (grep-verified: no `def`/`theorem
> valence` anywhere in Mathlib, no `argumentPrinciple`; `ModularForm.valence`, `ModularForm.divisor`,
> `CuspForm.valence`, `UpperHalfPlane.j`, `ModularForm.j` are all unknown constants in this pin).
> Every route in the brief dies at that same wall.
>
> **A route recorded in this file is a hypothesis, and one of them was FALSE — the dispatcher's own.**
> The brief's route (D) — "multiply `j - c` by a power of `Δ` and violate the Sturm bound" — is dead,
> and the dispatching brief's stated reason for rejecting it was wrong.  The refutation, checked by the
> dispatcher by hand against the `PowerSeries.order` API (the note's claim that
> `(qExpansion 1 g_m).order = m - 1` is the arithmetic `1 + (m-1) = m > (m-1)`): for `g_m := (j - c)·Δ^m = Δ^{m-1}·(E₄³ - cΔ)`, the leading term is `Δ^{m-1}`
> with coefficient `1` and the correction `-cΔ^m` starts one order higher, so
> **`(qExpansion 1 g_m).order = m - 1` for every `c : ℂ` and every `m`** — while
> `ModularForm.sturm_bound_levelOne` (`LevelOne/DimensionFormula.lean:305`) forbids only
> `order > k.toNat / 12 = m`.  So an interior zero of `g_m` is Sturm-compatible at every `m`; taking
> `m` large cannot repair the route.  (At `m = 1` the constant term of `E₄³ - cΔ` is `1`, so the only
> `Δ`-elimination lemma, `qExpansion_eq_qExpansion_discriminant_mul`, cannot even be *applied* — its
> hypothesis is exactly that this coefficient vanishes, so using it to prove the cusp order is
> circular.)
>
> **Route (F) is not an alternative:** `ModularGroup.exists_smul_mem_fd` plus
> `eq_one_or_neg_one_of_mem_fdo_mem_fdo` give only `LevelOneOrbitSeparation ↔ (j injective on 𝒟ᵒ mod
> ±1)` — the same target, approached differently.  A **restatement, not progress**; it must not be
> reported as partial progress on the Hauptmodul conjunct.
>
> **Dispatcher verification of this note:** the `sturm_bound_levelOne` citation was re-checked and is
> correct (`LevelOne/DimensionFormula.lean:305`, and `:286` for the `ℕ`-weight form), and the `order`
> arithmetic in the route-(D) refutation was re-checked by hand and is correct.  The **"unknown
> constant" negatives** (`ModularForm.valence`, `ModularForm.divisor`, `CuspForm.valence`,
> `UpperHalfPlane.j`, `ModularForm.j`, `modularLambda`, `Gamma2`) and the probes
> `ProbeM1L1g{A..E}.lean` are the **task's** evidence and were not independently re-run.
>
> **Also corrected here:** `Definitions/MMLevelOneHauptmodul.lean`'s header says "the cheapest known
> route is Mathlib's modular-forms dimension/valence machinery".  Mathlib has the **dimension** half
> only, and it is proved *from* the isomorphism `S_k ≅ M_{k-12}` plus base cases, so it cannot be
> inverted into a zero count.  There is no valence machinery to use.  Route (L) (λ/Γ(2)) is confirmed
> dead: no `modularLambda`, no `Γ(2)`/`Γ_θ` in either repository.
>
> **What that costs, honestly.**  A real proof of `LevelOneOrbitSeparation` needs the analytic valence
> formula for level one (`∑_{z ∈ 𝒟ᵒ} ord_z f / |stab_z| + ord_∞ f = k/12`, with the `1/3` and `1/2`
> weights at `ρ` and `i`): **1,500--3,000 lines** by the reconnaissance estimate, mostly
> `import Mathlib`-class modules (~93 s each).  There is no partial credit — a valence formula with a
> wrong constant is worthless — and everything on MM's side of it (invariance, surjectivity, the cusp
> expansion, the fundamental domain, the dimension formula) is already available.  The alternative is
> FLT's algebraic route at the price already recorded above (606 modules, 585 to compile).
> **This is a scope decision for the repository owner, and it is recorded here rather than taken.**
>
> **It is on the critical path, and the dispatcher checked the conjunction chain rather than trusting
> a first reading** (a first reading of the headline got this *wrong*): the conclusion of
> `MoonshineConjectureStatementGenus` is `IsGenusZeroGroup Γ ∧ IsAnalyticNormalizedHauptmodul Γ f a`,
> and `MM.IsAnalyticNormalizedHauptmodul` (`MNHauptmodulUniqueness.lean:119`) has
> `IsHauptmodul Γ f` as its **first conjunct**, which is invariance ∧ surjectivity ∧ **orbit
> separation** (`MMModular.lean:148-151`).  So the valence formula is what stands between this
> repository and an unconditional level-one theorem; `MM.IsGenusZeroGroup` alone does **not** carry
> orbit separation, and `MM.IsGenusZeroGroup.exists_isHauptmodul_of_orbitSeparation` takes it as an
> explicit hypothesis for exactly that reason.
>
> **Flavour of the saved evidence, so the next task does not redo it:** `ModularForm.discriminant : ℍ
> → ℂ` is *not* a `ModularForm` (it is the coercion of `CuspForm.discriminant`; `rfl`, yet invisible to
> `rw`); `levelOne_weight_zero_const` is `ModularFormClass`-namespaced; `ρ`, `I` are `UpperHalfPlane`
> variables and `1 +ᵥ ρ` is a third boundary point (the `cases_of_mem_fd_smul_mem_fd` split has nine
> cases); the `1/3`/`1/2` elliptic-point weights are load-bearing; `orbitMk` acts on the **second**
> argument; and `tools/build.sh --timeout` **is** implemented after all — the reconnaissance reported
> it as documented-but-missing, and the dispatcher checked: `tools/build.sh` parses `--timeout SECS`
> before its file list and enforces it with `timeout` at both the file and vendor call sites, printing
> `--- TIMEOUT (${TIMEOUT}s): <file> ---` on expiry.  The trap is positional, not missing: the flag
> must come **first**, or it is taken for a filename.  (Recorded because a reported blocker is a
> hypothesis too — this one was wrong, and it had already been copied into this file.)

### [x] M0 — the modular predicates diagnosed and repaired — **ACCEPTED (a) + (b); (c) folded into M1**

### [x] D0 — repair the definitions `MoonshineConjectureStatement` is phrased in — **CLOSED (a), (b), (c); D0-iii closed the two remaining items and proved the optional rewiring cosmetic**

> **AUDIT VERDICT (dispatcher-verified: the file was rebuilt and every key declaration re-checked
> with `#print axioms` before this was written).  `Definitions/MMStatementAudit.lean`.**
>
> **`MM.MoonshineModule` has no inhabitant.**  Proved, with the three standard axioms:
>
> ```lean
> theorem MM.no_moonshineModule (M : MM.MoonshineModule) : False
> theorem MM.not_moonshineConjectureStatement : ¬ MM.MoonshineModule.MoonshineConjectureStatement
> ```
>
> So `moonshine_conjecture`'s `sorry` and `not_moonshineConjectureStatement` are **contradictory**,
> and every theorem stated for an `M : MoonshineModule` — including the two guarded in
> `FinalCheck.lean` and everything in `Challenge.lean` — is **vacuously true**.  A green build with
> green `#print axioms` guards no longer carries its old meaning: the guards certify proofs about an
> empty structure.  This is the third defect of the same family in this project, after
> `IsHauptmodul` (unsatisfiable: `MMModular.lean`) and `IsHauptmodul` again (vacuous:
> `MMGenusZeroRefute.lean`).
>
> **Two independent defects, both proved, both needing repair:**
>
> 1. **`MM.MoonshineModule.hauptmodul` demands `IsBoundedAtImInfty f` *and*
>    `IsNormalizedHauptmodul Γ f (M.thompsonSeries g)`.**  The paper's normalized Hauptmodul takes
>    `i∞` to `∞` — it has a pole there and is therefore **unbounded** at that cusp; Mathlib's
>    `IsBoundedAtImInfty` speaks about that marked cusp only.  Drop the conjunct, or replace it by
>    boundedness at the *other* cusps.
> 2. **`MM.GradedModule.FiniteSupport` is *finite total support*
>    (`∀ g, {n | V.traceCoeff g n ≠ 0}.Finite`) — not what its own docstring says** ("the homogeneous
>    pieces vanish for all sufficiently negative degrees").  Finite total support is **false of the
>    FLM module**: `j - 744` has infinitely many nonzero coefficients.  It is also what makes the
>    `hauptmodul` field unsatisfiable, by an argument that does not mention the cusp at all:
>    `MM.not_surjective_of_finite_support_coeff` — if `f` is 1-periodic, `MDiff`, bounded at the cusp
>    and `HasQExpansion f a` with `{m : ℕ | a.coeff m ≠ 0}` finite, then `f` is a **finite sum of
>    monomials** `c_m q^m` with `‖𝕢 τ‖ < 1`, so `∀ τ, ‖f τ‖ ≤ Σ ‖c_m‖` and `f` is bounded on all of
>    `ℍ` — contradicting `Function.Surjective f`, which `IsHauptmodul` contains.  Weaken to "support
>    bounded below", which is what `HahnSeries` actually needs and what is true of FLM.
> 3. **`MM.HasQExpansion` never inspects the negative part of `a` — now CHARACTERISED, not merely
>    reported.**  `Definitions/MMQExpansionGap.lean` proves the limitation: the one-sided condition
>    **does** pin `a.coeff 0` once `f` is periodic and bounded at the cusp
>    (`MM.coeff_zero_eq_valueAtInfty`), but it can never constrain the negative degrees
>    (`MM.hasQExpansion_of_neg_eq`), so **no series is determined by it**
>    (`MM.not_determined_by_one_sided`) and the `q⁻¹` term of a normalized series is invisible to the
>    only link `IsNormalizedHauptmodul` has between `f` and `a`.  **THE REPAIR IS NOW LANDED** (task
>    T2-i, this session): `MM.HasLaurentQExpansion f a` in `Definitions/MMQExpansionTwoSided.lean`
>    writes the pole out as `f = a.coeff (-1) * qInv + g` with `g` periodic, `MDiff` and bounded, and
>    the series is then **determined** by `f` (`MM.HasLaurentQExpansion.eq`) — the exact negation of
>    `MM.not_determined_by_one_sided`.  Normalization becomes a property of `f`
>    (`…isBoundedAtImInfty_sub_qInv`, and conversely `…coeff_neg_one_eq_one_of_isBoundedAtImInfty_sub_qInv`),
>    `MM.isNormalizedLaurentSeries_iff` matches it to `MM.IsNormalizedSeries` on integer coefficients,
>    and the level-one instance is proved (`MM.levelOneJ_sub_hasLaurentQExpansion`, `q⁻¹`-coefficient
>    `1`, `q⁰`-coefficient `0`) from `MM.levelOneJ_cusp_expansion`.  **What is still NOT done:** the
>    coefficients are `ℂ`-valued, so **integrality** is untouched (the missing Lean step is in
>    `MMLevelOneCusp.lean`'s footer), and **`MM.MoonshineModule` has not been rewired** onto the
>    two-sided predicate — that rewiring changes the statement of Theorem 1.1 and is a dispatcher
>    decision, exactly as D0's item (c) says.  (Original report, for the record: Mathlib's `qExpansion`
>    is a `PowerSeries`, so the degree-`n` conjuncts only bind `n : ℕ`, and a faithful treatment needs
>    a `LaurentSeries` / `HahnSeries ℤ ℂ` `q`-expansion.
>    `MM.not_hasAnalyticNormalizedHauptmodul_single` shows the field's existential fails for
>    `a = q⁻¹`, which *is* `IsNormalizedSeries` — so the conclusion is **not** free.)
>
> **A correction to this entry's own earlier text, kept for the record.**  The 20-minute-lived claim
> that "surjectivity is now immediate" from the third conjunct of `IsHauptmodulAnalytic` was already
> wrong (M0(b)); the further claim that **boundedness at the cusp trivialises the `q`-expansion**
> — i.e. that `(qExpansion 1 f).coeff n = 0` for every `n ≥ 1` — was also wrong, and it is wrong
> **as a compiled counterexample**: `MM.qExpansion_coeff_one_qParamFun` shows `q ↦ q` is periodic,
> `MDiff` and bounded at the cusp yet has `q¹`-coefficient `1`
> (`not_forall_qExpansion_coeff_eq_zero_of_one_le`).  The Cauchy-estimate argument for it was
> vacuous: boundedness bounds the cusp function on a *fixed* punctured disc, and `n!/R^n` with a
> bound uniform in `R` gives nothing as `R → 0`.  Boundedness at the cusp bounds the coefficients by
> *geometric* growth; it does not kill them.  **Four dispatcher hypotheses about this one field were
> wrong in a row; the file records all four.**  The rule stands and applied to the dispatcher: a
> recorded route is a hypothesis.
>
> **Scope of the repair (a decision, not a task):** it changes `MM.GradedModule.FiniteSupport`,
> `MM.MoonshineModule.hauptmodul` and `MM.HasQExpansion`, i.e. the statement of Theorem 1.1.  Streams
> S, T, A and the whole M0 diagnosis are unaffected — they do not go through `MoonshineModule`.
> (**Taken**: see D0-e and D0-g below, which carry the rewiring and its equivalence theorem.)

> **RECONNAISSANCE VERDICT (dispatcher-verified: the probes were recompiled before this was
> written).  The spec below must NOT be dispatched as written, and the M0 line in "Ordering" is
> wrong for the same reason.**
>
> **1. `MM.IsHauptmodul` carries no analytic content at all.**  Its three conjuncts are invariance,
> surjectivity onto `ℂ`, and orbit separation — and the last two are supplied free of charge by the
> quotient map.  Proof (`Probe/ReconC.lean`, compiles, axiom-free): for **every**
> `Γ : Subgroup (GL (Fin 2) ℝ)` and every bijection `e : ℍ/Γ ≃ ℂ`, the function
> `fun τ => e (MM.orbitMk Γ τ)` satisfies all three, because `MM.orbitMk_surjective`
> (`MMModular.lean:83`) gives surjectivity and `MM.orbitMk_eq_iff` (`MMModular.lean:74`) gives
> separation.  No discreteness of `Γ`, no cusp, no holomorphy, no meromorphy is used anywhere.
> Consequently:
> * the spec's candidate repair `HasGenusZeroFun Γ := ∃ f, IsHauptmodul Γ f` is **`True` in
>   disguise** — proved for every `Γ`, with `HasGenusZeroFun Γ ↔ HasGenusZero Γ` given the
>   cardinality input, so it neither excludes `Γ₀(11)` nor adds anything;
> * a cusp-aware variant `∃ f, IsHauptmodul Γ f ∧ ¬ IsBoundedAtImInfty f` **is also vacuous**
>   (`Probe/ReconE.lean`, compiles): it implies `HasGenusZero`;
> * "whose field of rational functions generates the invariant field" is not statable here at all:
>   there is **no** invariant field, no `Hauptmodul` anywhere in Mathlib (grep: zero occurrences),
>   and no analytic `genus`; attached to `IsHauptmodul` it degenerates to its third conjunct.
> There is therefore **nothing to prove** in the shape the old spec asks for, and the old
> "Risk: medium … `IsHauptmodul` is already an analytic statement" is exactly backwards.
>
> **2. What survives, and it is worth having.**  `MM.IsHauptmodul` should nonetheless be *repaired a
> second time*: the honest predicate adds the two analytic conjuncts the paper actually uses,
> holomorphy on `ℍ` and unboundedness at the cusp.  `Mathlib` has the input:
> `UpperHalfPlane.qExpansion_eq_zero_iff` — "a periodic `MDiff` function bounded at `i∞` is
> determined by its `q`-expansion" — is precisely the removable-singularity + Liouville content, and
> it needs **no hypothesis on `Γ` beyond periodicity**.  This is already compiled in
> `Probe/ReconD.lean` as `eq_of_qExpansion_eq_of_bounded`.  From it one gets a genuine theorem:
> *a non-constant `Γ`-invariant holomorphic function unbounded at the cusp is surjective onto `ℂ`.*
> That is the first statement in this project about Hauptmoduls a mathematician would recognise,
> and it is Mathlib-only.
>
> **3. What still does not come out of it, and must not be claimed.**  It is a **witness** predicate,
> not a **criterion**: it cannot show `Γ₀(11)` is *not* genus zero, and `HasGenusZero` remains a
> cardinality condition.  Anything that would decide genus zero needs the compactified quotient — a
> Riemann surface, cusps and Riemann–Roch — i.e. task M1, months of work, not a spike.
>
> **4. FLT cannot supply the missing bridge** (measured, `Probe/ReconImport.lean` compiles in
> 5.3 s).  FLT's **definitions** layer is importable — MM's `build/lib/lean/Definitions/` already
> holds 27 FLT `Definitions` oleans — but its genus-formula **theorems** and `genusZeroLevels` sit
> behind the **1115-module** closure (only 4 `Theorems` and 7 `P2M` oleans exist), and, decisively,
> **FLT has no `genus 0 ⟹ F ≅ RatFunc` theorem and no algebraic-to-analytic bridge.**  Its genus is
> that of an algebraic function field; `MM.HasGenusZero` is about `ℍ/Γ`.  Nothing in FLT connects
> them.  So "genus zero via the function field" cannot be finished by importing FLT, and the M1
> risk reduction recorded in the stream-M box applies to the *genus number* only.

**Revised spec.**

* **(a) Record the defect as theorems, not as a paragraph.**  New file
  `Definitions/MMGenusZeroRefute.lean`, mirroring the `IsHauptmodulOldShape` /
  `not_isHauptmodul_old_shape` pattern of `MMModular.lean:166--187`: `HasGenusZeroFun`, its
  vacuity theorem for every `Γ`, and the honest docstring saying that `IsHauptmodul`'s second and
  third conjuncts are supplied by the quotient map.  This is the deliverable that matters, because
  the README currently sells `IsHauptmodul`'s repair as content and it is not.
* **(b) The analytic predicate — DELIVERED, with its limits recorded.**  Two new files, both
  importing `Definitions.MMModular` only, both building clean with 0 `sorry`/`axiom`:
  `Definitions/MMHauptmodulAnalytic.lean` (310 lines) and
  `Definitions/MMHauptmodulAnalyticRefute.lean` (231 lines), which holds the refutations so the main
  file stays readable.

  ```lean
  IsHauptmodulAnalytic Γ f :=
    (∀ γ ∈ Γ, ∀ τ, f (γ • τ) = f τ) ∧ MDiff f ∧
      ∀ c : ℂ, ¬ (MDiff (fun τ => (f τ - c)⁻¹) ∧ IsBoundedAtImInfty (fun τ => (f τ - c)⁻¹))
  HasPoleAtCusp f           := ∀ c : ℂ, IsBoundedAtImInfty (fun τ => (f τ - c)⁻¹)
  HasBoundedInvariantConst Γ := every Γ-invariant holomorphic function bounded at the cusp is constant
  ```

  **THREE candidate predicates were tried and the first TWO are refuted — do not use either.**
  * `invariance ∧ MDiff f ∧ ¬ IsBoundedAtImInfty f`: refuted by `τ ↦ τ` on `Γ = ⊥`
    (`not_forall_isHauptmodulAnalyticWeak_surjective`).  Unboundedness at the cusp does not control
    *how* `f` grows there.
  * `∀ c, ¬ (MDiff (f - c)⁻¹ ∧ IsBoundedAtImInfty (f - c)⁻¹)`: **also refuted**, and this was the
    dispatcher's own correction of the first candidate — a clean illustration of the standing rule
    that a recorded route is a hypothesis, and that the dispatcher's summary is one too.  The
    mathematics is one line: **"`f` misses `c`" and "`f` blows up at the cusp" are compatible with
    "`f` approaches `c` at the cusp"**, and nothing requires `f` to *attain* `c`.  Counterexample
    `f = exp` on `Γ = ⊥` (`not_forall_isHauptmodulAnalytic_surjective`): its only missed value is
    `0`, and at `c = 0` the third conjunct *holds* because `(exp τ)⁻¹` is unbounded at the cusp.
    **So no growth condition at the cusp can force surjectivity**, and the "surjectivity is now
    immediate" argument that stood in this entry for twenty minutes was wrong.

  **What DOES close** (both landed, both guarded):
  * `IsHauptmodulAnalytic.surjective_of_hasPoleAtCusp` — elementary: a missed `c` makes `(f - c)⁻¹`
    holomorphic, `HasPoleAtCusp` makes it bounded, exactly what the third conjunct forbids.
  * `IsHauptmodulAnalytic.surjective_of_hasBoundedInvariantConst` — the classical route, isolating as
    one hypothesis the compactness input the compact Riemann surface supplies.  Mathlib has it only
    at level one (`ModularFormClass.levelOne_weight_zero_const`); in general it is M1.

  **The deliverable is therefore CONDITIONAL, and is stated as such:**
  `IsHauptmodulAnalytic.toIsHauptmodul` takes `HasPoleAtCusp f` **and orbit separation** as explicit
  hypotheses.  Orbit separation is a genuinely independent gap, not a convenience: even with
  holomorphy, the pole condition and surjectivity, `f = j²` on `SL(2,ℤ)` is not injective on orbits
  (`j τ = - j σ` in different orbits gives `j² τ = j² σ`).  That is the paper's degree-1 /
  simple-pole condition, and ruling `j²` out needs the argument principle on `X(Γ)` — M1, not M0.
  **There is no unconditional `IsHauptmodulAnalytic Γ f → IsHauptmodul Γ f` in this Mathlib**, and
  the docstring says so rather than leaving it to be discovered.
> **D0-e LANDED (dispatcher decision, this session): the genus-zero conjunct is now non-vacuous.**
> `Definitions/MMGenusZeroStatement.lean` (272 lines) defines
> `MM.IsGenusZeroGroup Γ := HasGenusZero Γ ∧ HasBoundedInvariantConst Γ ∧ ∃ f, IsHauptmodulAnalytic Γ f ∧ HasPoleAtCusp f`
> and `MM.MoonshineConjectureStatementGenus`, with the reduction
> `MM.moonshineConjectureStatement_of_genus` to the current statement (so nothing is lost).  The
> added conjunct is not decoration, and **both** directions are theorems: `MM.hasGenusZero_bot`
> (from new hand-built equivalences `ℍ/⊥ ≃ ℍ` and `ℍ ≃ ℝ × ℝ`) with
> `MM.not_hasBoundedInvariantConst_bot` (witness `τ ↦ 𝕢 1 τ`) gives
> `MM.hasGenusZero_not_isGenusZeroGroup_bot`; symmetrically `MM.hasBoundedInvariantConst_top` and
> `MM.not_hasGenusZero_top`.  **No inhabitant of `IsGenusZeroGroup` is proved**, so the strengthened
> conjecture must not be quoted as known-satisfiable; the expected first instance is level one
> `𝒮ℒ` (compactness from `ModularFormClass.levelOne_weight_zero_const`, the analytic Hauptmodul from
> `MM.levelOneJ` + `MM.levelOneJ_surjective`, cardinality for the first conjunct) and that is the
> next task — **AND IT IS NOW DONE**: `Definitions/MMLevelOneGenusZero.lean` (320 lines) proves
> `MM.levelOne_isGenusZeroGroup : IsGenusZeroGroup 𝒮ℒ`, so the strengthened hypothesis is
> known-satisfiable in at least one case, with each conjunct proved for real (compactness via
> `ModularFormClass.levelOne_weight_zero_const` on a packaged `ModularForm 𝒮ℒ 0`; the pole via the
> `MM.levelOneJ_cusp_expansion` epsilon bound; the analytic Hauptmodul's third conjunct via the
> constancy argument; and the cardinality conjunct via the fundamental domain's imaginary axis and
> Schröder--Bernstein).  **The headline is still not re-pointed**: `MM.MoonshineModule`, its
> `MoonshineConjectureStatement` and `moonshine_conjecture` still use `HasGenusZero`, on purpose —
> the rewiring (swap the conjunct in the structure's `hauptmodul` field and in `Challenge.lean`) is a
> separate, explicit dispatcher step, to be taken once an inhabitant exists so that the strengthened
> hypothesis is known satisfiable.  That sequencing was the decision, and the condition is now met,
> so **the rewiring was taken (task D0-g, this session) and is DONE**:
> `MM.IsGenusZeroGroup` moved to `Definitions/MMGenusZeroGroup.lean` (upstream of `MMMoonshine.lean`,
> which previously could not see it — the import cycle is what fixed where the predicate lives); the
> structure's `hauptmodul` field now assumes `IsGenusZeroGroup Γ`; the conclusion of the standing
> `sorry` is `MM.MoonshineModule.MoonshineConjectureStatementGenus`; the pre-repair statement is kept
> unchanged with a *proved* implication from the new one
> (`MM.MoonshineModule.moonshineConjectureStatement_of_genus`); the two spellings of the strengthened
> statement are proved equivalent (`MM.moonshineConjectureStatementGenus_iff`); and the new goal's
> **non-vacuity is itself a theorem**
> (`…MoonshineConjectureStatementGenus.genusZero_exists`, yielding `IsGenusZeroGroup` for every
> element, where the old goal yielded only the cardinality condition).  `Challenge.lean` follows the
> new statement, with `moonshine_existence_weaker` as the proved corollary.  **The open content is
> unchanged**: constructing the module (streams S and T).  Nothing about `Γ₀(N)` or orbit separation
> is claimed.

> **D0-iii LANDED (a fresh task agent, dispatcher-verified by a from-scratch rebuild on 2026-09): both
> items this entry still left open are closed, and the rewiring is now known to be cosmetic.**
>
> * **`Definitions/MMLevelOneLaurentIntegral.lean` (166 lines): the level-one two-sided expansion is
>   INTEGRAL.**  `MM.levelOneLaurentSeries_eq_map_levelOneA : levelOneLaurentSeries = levelOneA.map
>   (Int.castRingHom ℂ)` — the complex series of `MM.levelOneJ_sub_hasLaurentQExpansion` **is** the
>   image of the integral series, coefficientwise (`q⁻¹ = 1`, below zero, nonnegative degrees via
>   `MM.qExpansion_levelOneCuspBounded` against `MM.levelOneA_coeff_nat`).  `MM.hasLaurentQExpansion_eq_map_levelOneA`
>   then uses the uniqueness `MM.HasLaurentQExpansion.eq` to make the value **forced**, not witnessed,
>   and `levelOneLaurentSeries_coeff_one` / `_two` compute `196884` and `21493760`.  **Nothing about the
>   Jacobi product is reproved**: the whole input is `MM.levelOneA_hasQExpansion` (task M1-L1h), which is
>   why the "missing Lean step" footer of `MMLevelOneCusp.lean` and the matching footer of
>   `MMQExpansionTwoSided.lean` are superseded rather than confirmed.
> * **`Definitions/MMHauptmodulTwoSided.lean` (288 lines): the predicate of the `hauptmodul` field and
>   the two-sided predicate are EQUIVALENT.**
>   `MM.isAnalyticNormalizedHauptmodul_iff_hasLaurentQExpansion` (carrier `b.coeff 0 = 0`) and
>   `…_and_cusp` (carrier `IsZeroAtImInfty (f - qInv)`, the two interchangeable by
>   `MM.HasLaurentQExpansion.isZeroAtImInfty_sub_qInv_of_coeff_zero` and its converse), both taking
>   periodicity and holomorphy of `f` — two hypotheses `MM.IsAnalyticNormalizedHauptmodul` itself does
>   not carry, the same pair `MM.IsAnalyticNormalizedHauptmodul.coeff_zero_eq_zero` already takes.
>   **So the rewiring of `MM.MoonshineModule`'s field changes nothing but the spelling, exactly to the
>   extent that those two hypotheses and the constant term are carried along; dropping any of them
>   changes the statement**, and the file says so where it matters.
> * **The rewiring itself was deliberately NOT taken** (it is the dispatcher step this entry reserved;
>   the equivalence theorem is the reason it buys no content), and **two brief errors were caught by the
>   task and are recorded**: the brief asserted (i) that `tools/build.ps1` works (it did not: its
>   `LEAN_PATH` put this package's build dir LAST, so every module importing `P2M.*` failed with
>   "object file … does not exist" even though the olean exists here — **repaired by the dispatcher**,
>   the order now matches `tools/build.sh` and the rule in `AGENTS.md`), and (ii) that the forward
>   direction of the equivalence is provable without periodicity and holomorphy of `f` (it is not).
> * Dispatcher verification, from scratch and not by trusting the author: `tools/build.ps1` over the 15
>   prerequisites in dependency order plus the two new files plus the dispatcher's own axiom probe →
>   16/16 `--- OK ---`, exit 0; `Probe/forbidden_tokens.py` → `sorry=0 admit=0 axiom=0
>   native_decide=0`; the dispatcher's probe prints `[propext, Classical.choice, Quot.sound]` for all
>   eleven declarations; `FinalCheck.lean` carries the same eleven `#guard_msgs` guards and builds
>   green (exit 0).  **Nothing in this project's headline changes**: the `sorry` is still the existence
>   of the module (streams S, T), and no genus, orbit separation or `Γ₀(N)` claim is made here.

* **(c) Do NOT replace `MM.HasGenusZero`.**  A separate predicate added beside it, or the statement
  of Theorem 1.1 changes under the README's `genusZero_exists` guard.  That is a dispatcher
  decision, not a task-level one.
* Acceptance: builds, no `sorry`, `#print axioms` exactly the three standard axioms, `FinalCheck.lean`
  green.
* **D0, the consequence that makes M0 urgent.**  With the present definitions,
  `MM.MoonshineModule.MoonshineConjectureStatement` (`MMMoonshine.lean:194`) reduces to
  `IsNormalizedSeries (M.thompsonSeries g) ∧ HasQExpansion f (M.thompsonSeries g)`: its first
  component is the vacuous `IsHauptmodul Γ f`, and `HasGenusZero Γ` is the cardinality condition.
  **The formalized statement of Theorem 1.1 therefore does not require `Γ` to have genus zero**,
  which is exactly the Conway--Norton input.  The existing `genusZero_exists` guard
  (`MMMoonshine.lean:227`) does not catch this, being an `∃ Γ, HasGenusZero Γ`.  Repair: phrase the
  conclusion with the analytic predicate instead of `HasGenusZero` + `IsHauptmodul`.  That changes
  the statement of the theorem, so it needs an explicit dispatcher decision and a README note; it is
  not a change to make silently inside a task.
* Risk: **low-medium**, with **(b)'s surjectivity step named as the failure point** — it needs a
  holomorphic square root of a nowhere-vanishing `MDiff` function on `ℍ` (equivalently a log), which
  Mathlib does not package; budget that step on its own.  The rigidity lemma (2) is already compiled,
  so no Picard argument has to be redone by hand.
* Will **not** deliver: `Γ₀(11) ∉ HasGenusZero`, any genus statement, any bridge to FLT, or a cusp
  compactification.

### [ ] M1' — the seven ATLAS elements and Koike's theorem
* Deliverable: the paper's section 9 case check: seven explicit elements `2B, 3B, 5B, 7B,
  9B, 13B, 15D` and the nonsingularity of `χ_i(g_j)` (determinant `2²²·3⁵·5·7·17`), plus the
  tabulated first five coefficients.
* Depends on S2 (needs the monster) and on the monster's character table, which does not
  exist in Lean.  Recorded as blocked.

---

## Stream A — the monstrous Lie superalgebras (sections 11--14, not needed for Theorem 1.1)

### [x] A1 — the `E8` lattice and its theta series (the finite half of section 11's Lemma 11.1) — **ACCEPTED**

**Goal.**  Lemma 11.1 (and if budget allows 11.2) of the paper's section 11, as power series
identities.  The paper states it for the *Fourier series*, and proves it by multiplying by `Δ` and
comparing finitely many coefficients — so it is formalizable as algebra of formal series, with no
modular-form theory required.

**Definition, confirmed from the paper's TeX source and by the user:**
`eta_{2+}(q) := eta(q)^8 * eta(q^2)^8`, where `eta(q) = q^{1/24} ∏_{n>0}(1 - q^n)` and
`Delta = eta^24`.  Lemma 11.1:

```
theta_{2E8}(q) / Delta(q)      = 1/eta_{2+}(q) + 1/eta_{2+}(q^{1/2}) + 1/eta_{2+}(-q^{1/2})
theta_{2E8+v1}(q) / Delta(q)   = 1/eta_{2+}(q^{1/2}) - 1/eta_{2+}(-q^{1/2})
theta_{2E8+v2}(q) / Delta(q)   = 1/eta_{2+}(q^{1/2}) + 1/eta_{2+}(-q^{1/2})
```

**Corrected and re-verified by the dispatcher (2026-09, exact integer series arithmetic).  The block
that stood here was WRONG — see the correction of record after it:**

```
eta_{2+}(q)          = q - 8q^2 + 12q^3 + 64q^4 - 210q^5 + ...   (the series previously written here
                                                                  was eta_{2+}/q, not eta_{2+})
1/eta_{2+}(q)        = q^{-1} + 8 + 52q + 256q^2 + 1122q^3 + 4352q^4 + ...
1/eta_{2+}(q^{1/2})  = q^{-1/2} + 8 + 52q^{1/2} + 256q + 1122q^{3/2} + ...
1/eta_{2+}(-q^{1/2}) = -q^{-1/2} + 8 - 52q^{1/2} + 256q - 1122q^{3/2} + ...
three-term sum       = q^{-1} + 24 + 564q + 8960q^2 + 105570q^3 + 996096q^4 + ...
Delta x that sum     = 1 + 240q^2 + 2160q^4 + 6720q^6 + ...      (= theta_{2E8}, paper line 2153)
Delta/eta_{2+}(q)    = eta(q)^16 eta(q^2)^{-8} = 1 - 16q + 112q^2 - 448q^3 + 1136q^4 - 2016q^5 + ...
```

**The paper is NOT misprinted here.**  `eta(q)^{16}eta(q^{1/2})^{-8} = q^{1/2} + 8q + 28q^{3/2} +
64q^2 + 126q^{5/2} + 224q^3 + 344q^{7/2} + ...` (`.tex:2156`) is **exactly right** — recomputed
coefficientwise here — and the claim that stood in the earlier revision of this block ("the true
expansion is `q^{1/2} + 8q + 52q^{3/2} + 256q^2 + ...`, so that display is misprinted") was **false**:
those are coefficients of `q · (1/\ddp)`, a different object.  The earlier block's `three-term sum`
and `theta_{2E8}/Delta` lines were shifted by one power of `q` for the same reason, and its
`eta_{2+}(q)` line was `eta_{2+}/q`.  Kept as a correction of record: a dispatcher's numeric
"verification" is a hypothesis until it is redone, and this one was wrong for a whole session.

**Status at that round: delivered with four `sorry`s, since discharged on the M-form route (below).**
Two files were produced and merged: `Definitions/MMLevelTwo.lean` — `E8` as the union of the integral
coset `D8` and the half-integral coset, `IsLattice`, `normSq` (`normSq_nonneg`,
`normSq_half_integral`), `sum_odd_sq_dvd`, `isLattice_iff`, the pruned enumerator `boxAux`/`box`, and
`thetaCoeff`; and `Definitions/ZZCond.lean` — the parity arithmetic for `ℤ`, including
`even_sum_iff_even_pair` and `even_sufficient`, which makes `Even (Σ yᵢ)` the correct coset condition.

`thetaCoeff_zero` is **proved** (task D-d2, combinatorially); the other three (`= 240`, `= 2160`,
`= 6720`) were then `sorry`, and the module's `## TODO: sorries to discharge` records the **corrected**
diagnosis (task D-d): the original `decide` forms for `n = 0` and `n = 1` did not finish in ~18 min,
the suggested `countP`/`Bool`-predicate rewrite did not finish `n = 1` in ~10 min, and the earlier
"11 s / 497 s / 31 s" figures should not be relied on — **the cost is the pruned enumeration `boxAux`
itself**.  The counts are settled in exact arithmetic (`1`; `112 + 128`; `1136 + 1024`;
`3136 + 3584`), each verified twice (`#eval` and an independent Python enumeration of the two cosets),
and the combinatorial route is: a soundness lemma for `box`, constructors for the small vectors, and
the classification of `Σ yᵢ² = 2n` (resp. `8n` with all coordinates odd) for `n ≤ 3`.
**Superseded by M-form** (below): the owner fixed the *route* as modular forms, so these are no longer
enumeration debts.

**Correction found by the task, and independently checked by the dispatcher.**  The brief for A1
said the half-integral coset condition is `4 ∣ Σ yᵢ`.  That is wrong: for `⟨z/2, y⟩ ∈ ℤ` for every
`y ∈ D8` the correct condition is `Σ zᵢ ≡ 0 (mod 2)`, i.e. **`Even`, not `4 ∣`**.  With `4 ∣` the
count comes out `112 + 64 = 176` instead of the paper's `240`; with `Even` it is `112 + 128 = 240`.
`Definitions/ZZCond.lean` proves both directions, so the model is pinned down rather than asserted.

**Warning recorded for everyone doing finite verification in this project.**  The dispatcher
initially "disproved" Lemma 11.1 by computing both sides in a script that truncated the
*intermediate* eta products at the same cutoff as the final answer, which silently dropped
coefficients; with a correct cutoff the identity holds.  **When checking a power series identity
numerically, truncate every intermediate product strictly above the target precision**, or the
result is worthless — and a wrong check of this kind nearly blocked a correct theorem.

**Policy for the remaining `thetaCoeff_*` work (superseded by the route change below):** discharge
them in one pass; the kernel cost of an enumeration cannot be avoided, so the honest fix is a general
lemma that the pruned box covers all vectors of norm at most `B`.

> **ROUTE CHANGE for the four theta-coefficient `sorry`s (owner's instruction, this session).**
> `Definitions/MMLevelTwo.lean`'s `thetaCoeff_one/two/three` were being discharged by *counting*
> lattice vectors (`thetaCoeff_zero` is already proved that way, combinatorially).  The owner has
> directed that the computation formula be proved **directly from modular forms** instead — i.e. the
> classical identity `θ_{E8} = ½(θ₂⁸ + θ₃⁸ + θ₄⁸) = E₄`, from which `thetaCoeff n = 240 σ₃(n)` and all
> four values follow with no enumeration at all.  Task **M-form** is that route, in three stages —
> (1) the coefficient-level identity for the repository's own `MM.thetaCoeff` by parity classification
> of `ℤ^8`; (2) `½(θ₂⁸+θ₃⁸+θ₄⁸) = E₄` via the theta transformation laws and Mathlib's
> `ModularForm.levelOne_weight_four_rank_one`; (3) `thetaCoeff n = 240 σ₃ n` and the three `sorry`s as
> corollaries.  The machinery is grounded: Mathlib has `jacobiTheta` with
> `jacobiTheta_S_smul`/`jacobiTheta_T_sq_smul` (nome `e^{πiτ}`, i.e. `Σ q^{n²/2}`) and
> `EisensteinSeries.E_qExpansion_coeff`; `fermats-last-theorem` has E₄'s integral q-expansion
> (`Thm_EisensteinSeries_ramanujan_system_qExpansion_int`), the divisor-convolution/Ramanujan
> identities (`Def_NumberTheory_DivisorConvolution`) and a Jacobi theta product identity.  **Neither
> has a lattice theta series or the E8 lattice**, so the lattice↔theta bridge is built here.  The
> riskiest step was stage 2's θ₂ multiplier system.
>
> **STAGE 2 LANDED, IN THREE FILES (and it retired that risk).**
> `Definitions/MME8ThetaModular.lean` — **the half-period evaluation
> `MM.jacobiTheta₂_half : jacobiTheta₂ (1/2) τ = jacobiTheta (τ + 1)`**; the brief had listed it as an
> existing library fact and **it does not exist in Mathlib** (the dispatcher re-ran that grep to
> confirm), so it was *proved* from the two series instead, and the correction is recorded in the file
> header and in `AGENTS.md`.
> `Definitions/MME8ThetaS.lean` — **`MM.thetaTwo_S_smul : θ₂(S•τ) = (-Iτ)^{1/2}θ₄(τ)`**, the classical
> `θ₂(-1/τ)` law, from Mathlib's two-variable functional equation at `z = 1/2` with
> `jacobiTheta₂_neg_left` and a `Complex.cpow_add` cancellation.
> `Definitions/MME8ThetaSCombination.lean` — **`MM.thetaCombination_S_smul`**: the combination
> transforms with weight 4 under `S` as well as `T` (stage 1), so the modularity is complete at the
> **generator** level; supporting lemmas include `MM.cpow_half_pow_eight : (z^{1/2})⁸ = z⁴` (no branch
> hypothesis) and `MM.thetaFour_S_smul`.
> **A second brief correction** is recorded in that file: the θ₄-law bookkeeping had been written
> inverted — the law is `θ₄(S•τ) = B·θ₂(τ)` with `B = (-I(S•τ))^{1/2}`, `B⁸ = (I/τ)⁴ = (τ⁴)⁻¹`, and
> since the law carries `B⁻¹` the eighth power of the actual multiplier is `τ⁴`: same weight,
> different accounting, and the `B` form dodges the `cpow` branch.
> **The convention that makes the law usable was settled from the source** (now an `AGENTS.md`
> bullet): `ModularForm.SL_slash_apply` is `(f ∣[k] γ) τ = f(γ•τ)·denom γ τ^(-k)` with
> `ModularGroup.denom_S : denom S τ = τ`, so the `S`-statement *is* weight-4 slash-invariance for `S`
> verbatim.
> **STEP 4a LANDED** (`Definitions/MME8ThetaModularForm.lean`, 130 lines): the combination
> `MM.thetaCombination := θ₂⁸ + θ₃⁸ + θ₄⁸`, its slash-invariance at the two generators
> (`MM.thetaCombination_slash_S`, `…_slash_T`), the group identification
> `MM.closure_mapGL_generators : Subgroup.closure {mapGL ℝ S, mapGL ℝ T} = 𝒮ℒ`, and hence the **full
> statement `MM.thetaCombination_slash_invariant {γ} (hγ : γ ∈ 𝒮ℒ) : thetaCombination ∣[(4 : ℤ)] γ =
> thetaCombination`** by closure induction over `SL2Z_generators`.  Three more traps from this round
> are in `AGENTS.md` (the `JacobiTheta` import chain carries no modular-forms scopes, so no `∣[k]` and
> no `SL_slash_apply`; `Subgroup.closure_induction` takes the generator case first and the membership
> last, and `Subgroup.map_top` does not exist; there is no `denom_T`, and the `mapGL`/`toGL (map …)`
> defeq trap requires stating the `denom` lemma in the goal's form).
> **What remains:** `MDiff` of the three θ's and of the combination, boundedness
> at the cusp, the `ModularForm 𝒮ℒ 4` assembly, then `½(θ₂⁸+θ₃⁸+θ₄⁸) = E₄` by
> `ModularForm.levelOne_weight_four_rank_one` + `EisensteinSeries.E_qExpansion_coeff`; then stage 3's
> two coset bijections give `thetaCoeff n = 240 σ₃ n` and the three `sorry`s as corollaries.  None of
> the stage-2 files enumerates anything (the only `decide`/`box` strings in them are docstrings).
>
> **Recorded fallback, deliberately NOT on `main`.**  The branch `task/d-d5-counting` (commit
> `3eb86ee`) holds a complete **whnf-safe counting proof of `MM.thetaCoeff_one`** (that branch reads
> `sorry=2`).  The dispatcher audited it: its `decide` occurrences are `ZMod 8`-scale checks,
> `decide_eq_true_eq` rewrites and per-coordinate term construction — no searches — and its assembly
> uses `rfl` on lambdas, never unfolding `MM.box`, so it satisfies the no-brute-force rule.  It is held
> back because the owner's directive fixes the *route* for the formula, and mixing provenances (one
> value by counting, the rest by modular forms) would muddy the record.  If the modular route stalls at
> stage 2, landing that branch is a one-step 3 → 2 reduction.

> **A1b RECONNAISSANCE (2026-09-13): STOPPED ON A DEFINITIONAL INCONSISTENCY IN THE SOURCE.  Do not
> dispatch a proof task here until it is settled — and it is a question for the owner, not for a task
> agent.**
>
> The first A1b dispatch burned its budget on reconnaissance and produced no Lean file.  It reported
> **the paper's definition of `\eta_{2+}` (line 2166: `\ddp(q) = \eta(q)^8\eta(q^2)^8`) to be
> inconsistent with the paper's own Fourier expansion three lines earlier (line 2157)**: with
> `\eta_{2+} = \eta^8\eta(q^2)^8` one has `1/\eta_{2+} = 1 + 8q + 52q^2 + 256q^3 + \ldots`, whereas
> the displayed series is `1 - 16q + 112q^2 - 448q^3`; the two readings are related by
> `\eta_{2+} \cdot (\eta^{16}\eta(q^2)^{-8}) = \eta^{24} = \Delta/q`, **not** by `1`.
> **That finding is FALSE and is retracted by A1B-CONVENTION-RECON below** — it compared `1/\eta_{2+}`
> with `\Delta/\eta_{2+}`.  What stood in doubt was only which object `1/\ddp(q)` denotes (an eta
> PRODUCT with positive exponents as printed, or the RATIO whose expansion the paper tabulates); the
> distance-`q^2` arithmetic above is the measured content, and the resolution is below.  A1b is off the
> critical path for Theorem 1.1 either way.

### [ ] A1b — Lemma 11.1 itself, and Lemma 11.2

> **A1B-CONVENTION-RECON LANDED (fresh task agent; the dispatcher re-read the primary-source lines and
> redid the arithmetic from scratch, 2026-09): Lemma 11.1's convention is DECIDED, and the
> "definitional inconsistency" this stream stopped on was an artefact of the repository's own record.**
>
> * `\ddp(q) = \eta(q)^8\eta(q^2)^8` exactly as printed (`.tex:2166`), with
>   `\eta(q) = q^{1/24}\prod_{n>0}(1-q^n)` (`.tex:506`) and `\Delta(q) = \eta(q)^{24}` (`.tex:494`).
>   `1/\ddp(q)` is the honest **reciprocal** — an eta quotient with leading term `q^{-1}` and constant
>   term `8` — and that is the object Lemma 11.1 is stated with.
> * The paper's tabulated `\eta(q)^{16}\eta(q^2)^{-8} = 1 - 16q + 112q^2 - 448q^3 + \ldots`
>   (`.tex:2158`) is **not** the expansion of `1/\ddp(q)`: it is `\Delta/\ddp(q)`, which is exactly
>   what the proof's "multiply both sides by `\Delta(q)`" produces.  Recomputed here by exact integer
>   series arithmetic: `1/\ddp = q^{-1} + 8 + 52q + 256q^2 + 1122q^3 + \ldots`, the three-term sum is
>   `q^{-1} + 24 + 564q + 8960q^2 + 105570q^3 + \ldots`, and `\Delta \times` that sum is
>   `1 + 240q^2 + 2160q^4 + 6720q^6 + \ldots` — the paper's `\theta_{2E_8}` (`.tex:2153`).
> * **So the half-integral-shift, branch-choice and typo hypotheses are all refuted for Lemma 11.1**,
>   and the branch in `\eta(-q^{1/2})` is *forced* (`\mu = -1`) rather than free.  **Lemma 11.1 is
>   therefore unblocked as a statement** — the owner's confirmation of the reading is invited, since
>   this roadmap reserved that decision — and it is a well-posed formal power series identity needing
>   no modular-form theory, only `PowerSeries`/`HahnSeries` algebra of the kind T1 already provides.
> * **Lemma 11.2 stays BLOCKED, for a reason independent of any convention.**  The printed signs at
>   `.tex:2196` (four `-`) and `.tex:2198` (four `+`) add to
>   `\theta_{\Lambda_2} + \theta_{\Lambda_2+v_3} = \Delta/\ddm(q) = 1 - 32q + 480q^2 - \ldots`, but
>   both summands are coset theta series with non-negative coefficients and
>   `\theta_{\Lambda_2} = 1 + 4320q^2 + \ldots` has `q^1`-coefficient `0`: a sum of non-negative
>   series cannot have `-32` at `q^1`.  Independently, `\Delta/\ddm(q^{1/4})` read literally is a
>   `q^{1/12}`-series starting at `q^{3/4}`, whereas the tabulated partner (`.tex:2185`) is a level-2
>   series starting at `q^1`.  **No delivered source settles Lemma 11.2** (checked against Gannon,
>   FLM, Jurisich and Barraclough), so its first deliverable is the resolution of those two points —
>   by the owner, or against Borcherds' own later errata — **not** a Lean file.
> * **Corrections to this repository's record, all verified here and all corrected in place:**
>   (i) the A1b block's central claim ("the paper's definition of `\eta_{2+}` is inconsistent with the
>   paper's own Fourier expansions") is **false** — it compared `1/\eta_{2+}` with `\Delta/\eta_{2+}`;
>   (ii) the A1 row's claim that `.tex:2156` is misprinted is **false** — recomputed coefficientwise,
>   and that row now carries the corrected series; (iii) `README.md`'s eta-product form for
>   `\theta_{2E_8}` was false by weight (`\eta^8\eta(q^2)^8` is `\ddp`, of weight 8 and positive order)
>   and is corrected there; (iv) `AGENTS.md`'s source table called `魔群月光/RWBphd.pdf` "Borcherds'
>   thesis" — it is **Barraclough**, *Some Calculations Related To The Monster Group* (Birmingham
>   2005), while Borcherds' thesis is `魔群月光/THESIS.PDF` (*The Leech lattice and other lattices*) —
>   and it claimed `pdftotext` is installed, which it is **not** on this machine (`python` + `pypdf`
>   is the route); all four are fixed.
> * Full report, including Lemma 11.1 written out in Lean terms and the price of its proof:
>   `Probe/A1B_CONVENTION_RECON.md` (gitignored — this block is its committed substance).

> **M-FORM (owner-directed, this session): the `thetaCoeff` values are to be proved FROM MODULAR
> FORMS, not by counting.**  `Definitions/MME8Theta.lean` (180 lines, stage 1 done) defines the three
> Jacobi theta functions on top of Mathlib — `thetaThree = jacobiTheta`, `thetaFour = θ₃(·+1)`, and
> `thetaTwo = e^{πiτ/4}·jacobiTheta₂(τ/2) τ`, the bridge from the library's **two-variable**
> `jacobiTheta₂` (**not** the classical `θ₂`; the naming trap is recorded in the header) to
> `Σ q^{(n+1/2)²/2}` — and proves the `q`-expansions, the `T`-shift laws, the multiplier law
> `θ₂(T·τ) = e^{πi/4}θ₂(τ)`, and **`thetaCombination_T_invariant`**: `θ₂⁸+θ₃⁸+θ₄⁸` is `T`-invariant
> although no single term is.  **The `S`-side's engine is identified, not missing:**
> `jacobiTheta₂_functional_equation` (the two-variable Poisson identity) at `z = τ/2`, plus
> `jacobiTheta_S_smul` and `jacobiTheta₂ (1/2) σ = θ₄(σ)`.  Remaining stages: (2) the `S`-laws for
> `θ₂`/`θ₄` and hence `½(θ₂⁸+θ₃⁸+θ₄⁸) ∈ ModularForm 𝒮ℒ 4`, concluded to be `E₄` by
> `ModularForm.levelOne_weight_four_rank_one` (both sides weight 4, constant term 1); (3) the
> coefficient-level bridge to `MM.thetaCoeff` (a bijection between the two cosets and the supports of
> `½(θ₃⁸+θ₄⁸)` and `½θ₂⁸` — no search), and then `thetaCoeff_one/_two/_three` as corollaries of
> `thetaCoeff n = 240 σ₃ n`.  **Rule 2 of `AGENTS.md` (no brute-force enumeration) governs all of
> this**, and the superseded counting layer for `n = 1` stays preserved on `task/d-d5-counting` as
> evidence, not to be extended.

With the lattice and theta-series half in place, the remaining work of section 11 is to *discharge*
the four `thetaCoeff_*` sorries, then state Lemma 11.1 with `eta_{2+} := η^8 · (η ∘ q ↦ q²)^8` and
prove it by the paper's method (multiply by `Δ` and compare coefficients).  Lemma 11.2 has weight
`8` and involves `i = √-1`; it needs the weight-`8` analogue.  Neither is on the critical path for
Theorem 1.1 (stream A is not needed for it), so it stays behind T1b/T2 and M0/M1 in the ordering.

### [ ] A2 — a fake monster Lie algebra denominator formula
* Deliverable: the product identity of section 13 stated as a formal power series identity.
* Risk: high; depends on A1 and on root-multiplicity combinatorics.

---

### Batch 151, final acceptance

`Probe/agentbuild.sh Definitions/MMFLM85HrelClose.lean` -> `--- OK ---`, exit 0; the file passes
`Probe/forbidden_tokens.py` at `sorry=0 admit=0 axiom=0 native_decide=0`; all 9 in-file guards
matched verbatim, every footprint `[propext, Classical.choice, Quot.sound]`, none touching `sorryAx`.
`FinalCheck.lean` acceptance build: `Probe/b151_final_accept.log`.

**The dispatcher repaired three defects in the landed file before acceptance**, and they are worth
recording because each is a distinct failure mode of a *dispatched* agent's product:

1. `normalOrderedFam_label_add_at` failed to synthesize `Module.Free ℤ L` (the ambient instance is
   not derivable from the explicit `bL : Module.Basis κ ℤ L` parameter) -- **and Lean reported the
   consequence, not the cause**: the declaration's axiom footprint came out as
   `[propext, sorryAx, Classical.choice, Quot.sound]`, i.e. an *unproved* declaration with no `sorry`
   anywhere in the file text.  `Probe/forbidden_tokens.py` passes such a file; only the
   `#guard_msgs` axiom guards catch it.  **This is the second independent reason a dispatched agent's
   file must be compiled by the dispatcher, not read.**  Fix: `haveI : Module.Free ℤ L :=
   Module.Free.of_basis bL`.
2. Two imports were missing (`MMFLM85Action` for `MM.FLM85Ac.factorFamily`, and
   `MMFLM85LabelLinearity` for `MMFLM85LL.factorFamily_add`): the file had been written against the
   *author's* import closure, which the interrupted run never rebuilt.
3. **A name-resolution defect that survived both fixes, and whose cause is not yet known**:
   `MM.FLM85Ac.factorFamily` resolves as a *simple* identifier under `open FLM85Ac` in a minimal probe
   with the same imports (measured: `Probe/b151_probe4.lean`, exit 0) but **not** inside this file's
   body, where Lean reports `unknown identifier factorFamily` and suggests `autoImplicit`.  It is
   fixed by fully qualifying the two occurrences; the *cause* is recorded as unknown rather than
   explained away, because a silently-unresolvable `open`ed name is the kind of thing that will recur.

**What batch 151 leaves open, precisely.**  `Hrel` is closed, so `generalVertexOperator_existsUnique`
now produces the general vertex operator with **no hypothesis** and `MM.FLM810F.theorem8102_of_hrel_modelBase`
has lost its last free input on the relation side.  What is *not* done:

1. the four `ActionRemainingFields` conjuncts (Jacobi, `L(0)` grading, translation, Virasoro) for the
   corrected action prescription -- the honest assembly boundary of `MM.FLM810CA.theorem8102_of_remainingFields`;
2. **Theorem 8.6.1's display**, which by `MM.FLM86TDA.residue863_iff_corollary851` is equivalent to
   `MM.FLM85Co.Corollary851` at the states of (8.6.2), and by
   `MM.FLM86TDA.display863_of_jacobiIdentity` follows from a Jacobi identity plus the finiteness
   `hvan`.  The two remaining questions there are (a) the **concrete** field on `V_L`
   (`annihExp · actVL · creationExpVL`, all landed) and its two-point product identity, and (b) the
   **uniform-in-`(m,n)`** vanishing `hvan`, which the VOA axioms supply only per component.  Both are
   stated with their exact types in `Probe/briefs/B151-W3-vacuum851.md` and
   `Probe/briefs/B151-W4-assembly.md`.

---

### Batch 152, final acceptance — **Theorem 8.6.1's display is a theorem, and its last input is one named `Prop`**

`Definitions/MMFLM86UniformVanishing.lean` (460 lines) and
`Definitions/MMFLM86DisplayVOASplit.lean` (319 lines) both build `--- OK ---`; both pass
`python3 Scratch2/forbidden_tokens.py` at `sorry=0 admit=0 axiom=0 native_decide=0`; the 14 + 11 in-file
`#guard_msgs` axiom guards all match verbatim with footprints `[propext, Classical.choice, Quot.sound]`
or narrower and none touching `sorryAx`; `FinalCheck.lean` acceptance build is `--- OK: FinalCheck.lean
---` (`/tmp/finalcheck.log`), with the four new guards appended.

**The display (8.6.3) is landed as a theorem.**  `MM.FLM86DVS.display863_fixed_window` proves, at a
**fixed** window `K` (no `∃K`, no extra hypothesis beyond the two named inputs),

    `MM.FLM86TDA.Display863 form E Y u' v' a b K`,

from exactly two inputs: the faithful (8.10.8) `MM.FLM810JF.FaithfulJacobi Y u v` — which is *verbatim*
the `jacobi` field of the landed `MM.FLM810.VertexOperatorAlgebra` — and the finiteness parenthetical of
(8.5.26) at `K`.  `display863_of_voa_self` is the transport-free form for a structure's own field;
`display863_of_remainingFields` is the Section 8.10 assembly form, and it consumes **only the
`JacobiAxiom` conjunct** of the four `ActionRemainingFields`, none of `hpd`, `heven`, `hrank`, `hW`,
`hfin`.

**The finiteness parenthetical is one line from the axiom (8.10.5)**, and that corrects the campaign's
own framing of it.  `MM.FLM86UV.exists_uniform_bracketTerm_vanishing` proves the uniform-in-`(m,n)`
vanishing of `MM.FLM85Br.bracketTerm` from `A.componentTruncation` alone — no grading, no homogeneity, no
weight: *the source's parenthetical is (8.10.5) at the pair `(a,b)`.*  Batches 144--151 carried it as
"the VOA axioms supply truncation only per component, not uniformly in `(m,n)`" (see batch 151's §2
above and NOTES §64.4); that is **wrong** for the pair-indexed form the display needs — it is right only
for the *operator*-valued `MM.FLM88.JacobiIdentity` window, which the display does not consume.
`exists_iterate_uniform_vanishing` gives the `ℤ`-indexed form `∃K, ∀ i ≥ K, iterateOf Y a b i = 0`.

**So Theorem 8.6.1 now rests on exactly one input, and it is named.**  Reading the display's right-hand
side as the `Res_{z₀}` face (`display863_iff_residue863` + `residue863_iff_corollary851`) the theorem is
`MM.FLM85Co.Corollary851 (toVertexOp Y) u v K` at the states of (8.6.2), from `FaithfulJacobi`.  What is
*not* claimed: the paper's proof of (8.6.3) via (8.6.11)--(8.6.27) is not reproduced; the display is
reached through the Jacobi axiom instead.  The concrete field on `V_L` is not needed, and neither is the
two-point product identity that batches 146--151 were aimed at.

**The concrete residual.**  `FaithfulJacobi Y u v` for the corrected action prescription is
`FaithfulJacobi`-on-generators, which `MM.FLM810RR.jacobiAxiom_of_stateTargets` already reduces to
`MM.FLM810RR.JacobiOnStateTargets bL form Y` (`Definitions/MMFLM810RemainingReduction.lean:166`).  So
Theorem 8.6.1 is now conditional on **that one landed `Prop`** and nothing else.

**A landed definition is refutable, and this is the batch's second finding.**
`MM.FLM85.WeightGrading.IsHomogeneousOp S T p` requires `S.wt (T a) = S.wt a + p` also at `a = 0`, where
it reads `S.wt 0 = S.wt 0 + p`; hence `MM.FLM86UV.isHomogeneousOp_eq_zero` gives `p = 0` for **every**
operator `T`, and `not_isHomogeneousOp` refutes the predicate at every `p ≠ 0`.  Every landed lemma
taking an `IsHomogeneousOp` hypothesis is therefore **vacuous** — including
`MM.FLM85Br.bracketTerm_vanishing_of_grading` and the batch-152 `*_on` statements that generalise it,
and the `hOp` hypotheses of `MM.FLM85Br.component_eq_zero_of_toNat_le`,
`weightOfComponents_of_isHomogeneousOp` and the whole Corollary 8.5.6 chain.  The satisfiable repair is landed here as `MM.FLM86UV.IsHomogeneousOpOn`
(the same statement with the `T a = 0` case dropped, where `WeightGrading.wt_eq_of_mem` has no content),
with `IsHomogeneousOp.isHomogeneousOpOn` recording that it generalises the landed predicate, and the
uniform-vanishing statements reproved under it.  The batch's brief had asked for a theorem *from*
`IsHomogeneousOp`; the agent measured that the hypothesis is unsatisfiable instead of proving a vacuous
statement, and that measurement is worth more than the theorem would have been.

**Cost note (measured).**  Two dispatched agents were launched at 22:58 and both were killed at the
owner's instruction at ~23:21, having written their files but not their reports; the dispatcher built,
guarded, extended (`display863_fixed_window`), wired into `FinalCheck.lean` and accepted them.  Of the
~23 minutes, roughly 12 were spent queueing on the build lock held by a stale `lean --server`.

---

### Batch 153, reconnaissance — **the residual is not a proof gap, it is a wrong field**, and Theorem 8.6.1 is therefore not one lemma from done

Owner's directive for this session: *finish Theorem 8.6.1*, dispatching work to fresh subagents in
batches.  The batch opened with two reconnaissance agents (dispatch rule of `AGENTS.md`: fresh agents,
self-contained briefs, no forking) whose reports are `Probe/B153_R1_PROVED.md` and
`Probe/B153_R2_VOA.md`.  Their findings, all re-verified here by reading the cited lines:

**(1) The display is not the gap; the field is.**  By `MM.FLM86TDA.display863_iff_corollary851` and
`MM.FLM810RR.jacobiAxiom_of_stateTargets`, Theorem 8.6.1's display is closed once
`JacobiOnStateTargets` holds for the concrete field.  **It cannot hold**, because two of the four
sibling fields of the same boundary are *refuted* at exactly the field the target quantifies over:

* `MM.FLM810ModesL0.lean:370` `l0OnWeightGenerators_forces_zero` and `:398`
  `not_l0OnWeightGenerators_modelBase` — `L0OnWeightGenerators` is **false** for the field of
  `MM.FLM85AP.actionPrescriptionTA` at the (8.4.17) model base as soon as a lattice vector of nonzero
  even norm exists (for the Leech lattice: it does);
* `MMFLM810TranslationStateObstruction.lean:271` `not_translationOnStateData_modelBase` —
  `TranslationOnStateData` is false there as well.

Both are consequences of **one definitional defect**: the (8.4.7) Heisenberg field
`MM.FLM85Cp.heisFam a = fun m => modeVL a (−m−1)` has `modeVL a 0 = 0` at the power `m = −1`, i.e. it
omits the (7.1.33)/(7.1.41) zero mode `a(0)`, which in FLM acts on the lattice factor by the pairing
`a(0)·ι(b) = (a,b)ι(b)`.  **So the campaign's "last named `Prop`" is not an open problem — it is an
unsatisfiable one, at the only field the repository has for it.**  This supersedes the closing sentence
of batch 152's ledger entry above, which read the residual as "one landed `Prop` and nothing else": the
`Prop` is landed, and *false*.

**(2) The repair is landed and unconditional, but it is not wired into the assembly.**  Batch 80's
files restore the zero mode and are complete on their own terms:

* `MM.FLM85ZM.heisFamZero` (`Definitions/MMFLM85ZeroModeField.lean:116`) — (8.4.7) with `a(0)` at the
  power `−1`;
* `MM.FLM85ZP.actionPrescriptionTAZero` + **unconditional** existence--uniqueness
  `existsUnique_actionPrescriptionTAZero` (`MMFLM85ZeroPrescriptionSpanning.lean`), i.e. (8.5.1) with
  (8.5.6) for the corrected prescription — the relation-spanning input is *the same proposition* as
  the landed one, because the relation module never mentions the Heisenberg field;
* `MM.FLM810ZMU.Yzero` with `Yzero_spec`/`Yzero_unique` (`MMFLM810ZeroModeL0Uncond.lean:82`, `:87`,
  `:107`) — the unique concrete `Y`, henceforth **the** field of the construction;
* `MM.FLM810ZMW.L0OnWeightGenerators_zero` (`MMFLM810L0General.lean:301`) — (8.10.12) at the vacuum
  generators for that field, where the landed prescription gave `0`.

But `MM.FLM810CA.theorem8102_of_remainingFields` still takes `actionPrescriptionTA`, and **there is no
assembly line for `actionPrescriptionTAZero`** — no corrected `ActionRemainingFields`, no corrected
`theorem8102_of_generatorFields`.  That is the structural blocker, and it is mechanical.

**(3) Every `l ≠ 0` face of the Jacobi identity is untouched**, and the objects FLM uses for it —
the localisation `F[z₁,z₂]_S` and the maps `ι_{i₁⋯iₙ}` of (8.10.36)--(8.10.42) — do not exist in the
repository (`Definitions/MMFLM88Jacobi.lean:189` records this).  The `l = 0` face, which is what the
display is, *is* equivalent to the named open `MM.FLM85Co.Corollary851`
(`Definitions/MMFLM88Jacobi.lean:588` `corollary851_iff_jacobiIdentity_zero_face`).  The two window
conjuncts are **free**: `crossWindowVectorwise_of_truncation`/`iterateWindowVectorwise_of_truncation`
need only `ComponentTruncation`, which *is* proved for the concrete field
(`MMFLM85ActionTruncationTA.componentTruncation_of_actionPrescriptionTA`).

**(4) There is exactly one `VertexOperatorAlgebra` literal in the repository**
(`Definitions/MMFLM810Axioms.lean:923`), its state space is the real `V_L`, and **all five of its
fields are hypotheses**; `grep -rn "instance.*VertexOperatorAlgebra"` is empty.  The vendored
`VertexAlg` Borcherds identity is a *class field* with no construction upstream and is not connected to
`MM`'s `VL` (different carrier, no shared import); its one concrete field is refuted.  The
`IsHomogeneousOp` weight route is dead (batch 152).  **Reconnaissance verdict: (8.10.8) is not
derivable from anything landed, and the honest cost of the remaining chapter is ~3.5--6.5 kLoC.**

**(5) What this means for the plan.**  Theorem 8.6.1 is *not* one lemma from done.  Two routes remain,
and both are now being worked as batch 153's proof tasks on disjoint files:

* **P1 (`Definitions/MMFLM86ExpProduct.lean`)** — the concrete exponential two-point product on `V_L`
  (`Y(ι(a),z₁)Y(ι(b),z₂) = ε(a,b)·:Y(ι(a),z₁)Y(ι(b),z₂):·(z₁−z₂)^{(a,b)}` and its commutator corollary).
  This is FLM's *own* engine for Theorem 8.6.1 — the display is the `Res_{z₀}` face of the Jacobi
  identity, and for the lattice states that face is this product identity.  It is finite, explicit, and
  independent of the §8.10 rationality machinery.
* **P2 (`Definitions/MMFLM810CorrectedZeroAssembly.lean`)** — the corrected assembly line for `Yzero`:
  the four-field package and the `theorem8102` boundary restated at the zero-mode prescription, so that
  the field the refutations are about is no longer the field the assembly consumes.

This batch's reconnaissance is itself the deliverable of the round: it changes the target from "prove
one `Prop`" to "repair the field, then prove the product identity", and it is recorded because the
repository's own ledger had the residual wrong.

**(6) The product-identity ledger, measured (`Probe/B153_M2_PRODUCTLEDGER.md`).**  A second measurement
agent tabulated every `def … : Prop` matching `Product|Diag|Contraction|Expand|Ordinary|Statement|
Obligation|Window` across `Definitions/MMFLM85*.lean` and `MMFLM86*.lean` (44 objects), every
conclusion-position occurrence and every consumer, plus all 58 refutation-shaped declarations.  The
three findings that change what may be dispatched:

* **(8.5.12) is open through *three* named `Prop`s, not one.**  `ProductExpansion8512`
  (`MMFLM8512Done.lean:475`) has a single conditional producer (`MMFLM84Diag.lean:507`) whose
  hypotheses are `Iterate8436` (`MMFLM84Diag.lean:440`, whose only conclusion-position occurrence is
  the `Iff.rfl` re-spelling `iterate8436_iff`), `StateVanishesBelow` (`MMFLM85Corollary.lean:510`,
  whose only producer needs `StateFamilyStatement`, `MMFLMLatticeState.lean:567`, **which has no
  producer at all**) and `ModeFamHeisShift` (`MMFLM8512Heis.lean:221`, `Iff.rfl` only).  The same
  agent measured that the residual for the Heisenberg-shaped reading is `Iterate8436` at `k ≥ 1` plus
  `StateFamilyStatement`, and that `ModeFamHeisShift` is a *separate mis-shaping defect*
  (`MMFLM8512Heis.lean:192`) rather than a third independent input.
* **The grading chain is vacuous, and this was verified here line-by-line.**  `MM.FLM88`'s
  `corollary854_of_jacobiIdentity_grading` (`:553`) and `MM.FLM85Co`'s
  `corollary855_of_corollary851_grading` (`:744`) both take
  `hOp : ∀ n, S.IsHomogeneousOp (component Y n a) (S.wt a - n - 1)`, i.e. the predicate batch 152
  refuted (`MM.FLM86UV.not_isHomogeneousOp`).  So the two "grading" routes to Corollaries 8.5.4/8.5.5
  are **vacuous**, and any plan reaching `Corollary851` through them must be re-stated with
  `MM.FLM86UV.IsHomogeneousOpOn` — whose non-vacuous uniform statement
  `bracketTerm_vanishing_of_gradingOn_uniform` (`MMFLM86UniformVanishing.lean:271`) is already landed,
  with the blanket `_uniform` form (`:287`) documented as the vacuous one it generalises.
* **For the concrete `V_L` field the unconditional assets are exactly three**: the field itself
  (`MMFLM85PermSpanning.existsUnique_actionPrescriptionTA:272`, `MMFLM85HrelClose.generalVertexOperator_existsUnique:251`,
  `MMFLM810ZeroModeL0Uncond.Yzero_spec:87`), `ComponentTruncation`
  (`MMFLM85ActionTruncationTA.componentTruncation_of_actionPrescriptionTA:63`) — which is what makes
  both Jacobi window conjuncts free — and `L0OnWeightGenerators_zero` (`MMFLM810L0General.lean:301`),
  the latter for `Yzero` only.  **No product statement for the concrete field is unconditional**, and
  the abstract convolution's additivity *fails* without local finiteness
  (`MMFLM85ConvAdditive.not_conv_add_right_unconditional:315`).  This is the honest starting line for
  the exponential product identity (task P1).

**(7) The concrete exponential API, measured (`Probe/B153_M1_EXPAPI.md`).**  A third measurement agent
mapped the exponential layer and, decisively, **reduced the whole of Theorem 8.6.1's empty-oscillator
case to one already-named `Prop`**:

* The concrete exponentials are `MM.FLMLatSt.creationExpVL`
  (`Definitions/MMFLMLatticeState.lean:199`, the creation half `E^-`) and `MM.FLM84CM.annihExp`
  (`Definitions/MMFLM84Completion.lean:682`, the annihilation half `E^+`).  All five contraction lemmas
  that move a mode or the zero mode past a creation exponential are landed
  (`MM.FLM84CT.modeVL_comm_creationExpVL:375`, `:436`, `MMFLM84TwoVarProduct.lean:600`,
  `MM.FLM84CT.hZeroVL_comm_creationExpVL:639`, `hZeroVL_contraction:659`, `MM.FLMLatSt.creationExpVL_mul_actVL:333`,
  `annihExp_mul_creationExpVL_eq_sum_of_subset` `MMFLM84RatioWindowClose.lean:813`).  **No
  normal-ordered product formula for two creation exponentials exists**, the only product statement
  being the commutation `creationExpVL_comm` (`MMFLM84TwoVarProduct.lean:624`).
* **The object mismatch that has been costing the campaign is now named**: `actionPrescriptionTA` folds
  oscillator factors built from `heisFam a m = modeVL a (−m−1)` (`MMFLM85Compat.lean:213`), while the
  (8.4.36) display and its product expansion use `modeFam Y a m = Y (iotaVL a) (−m−1)`
  (`MMFLM8512Done.lean:403`).  The two are identified **only** by the `Prop`
  `MM.FLM8512H.ModeFamHeisShift` (`MMFLM8512Heis.lean:221`) — which has no producer anywhere.  This is
  the second, independent mis-shaping defect of the same construction, alongside the missing zero mode.
* **The reduction.**  `theorem842Concrete_iff_corollary851` (`MMFLM8512Done.lean:805`) with
  `theorem842Concrete_iff_apply` (`:793`) identifies `Theorem842Concrete Y E a b (form a b) K` with
  `Corollary851 Y (iotaVL a) (iotaVL b) K`, and `stateOf_one_eq_iotaVL` is `rfl`, so this *is*
  `Display863Unshifted form E Y 1 1 a b K` (`MMFLM86TheoremDisplay.lean:163`) — the empty-oscillator
  case of (8.6.3)'s second sentence.  **So `Theorem842Concrete` at the lattice generators is exactly
  the `(1,1)` case of Theorem 8.6.1**, and it is one named `Prop`.
* **What does *not* lift it**: `theorem861Source_of_coeffFamily_and_spanning`
  (`MMFLM86SpineGap.lean:632`) is proved, but its spanning hypotheses are families `A, B` with their
  own coefficient conditions; the pure lattice generators do not span `V_L = M(1) ⊗ F{L}`, so the
  `(1,1)` case does **not** lift to general `u', v''` by it.  The spanning input is Remark 8.3.9, not
  landed, and no landed lemma moves a Fock creation operator past `iterateOf`/`commutatorFamily`.
* **The remaining mathematics, priced in four printed steps**: (a) (8.5.12)'s `k ≥ 1` lines, i.e.
  (8.5.5) at the Fock states `E_k·ι(a+b)`, plus the `ModeFamHeisShift` dictionary; (b) the (8.4.35)
  commutator identity with its contraction factor; (c) the `z_1 = z_0 + z_2` shifted resummation
  (`MMFLM86MixedProduct.jointNO:345` lands the shift object; its identification with the iterate is
  `DiagOrdinary`, unproved); (d) the Fock half of (8.5.5).  Not needed: the window
  (`Corollary851.canonical:536`) and the (8.6.1) symmetry hypothesis.

### Batch 153, acceptance — **the corrected assembly boundary is landed, and the "repaired field" turned out to be a third defect**

Two proof tasks were dispatched on disjoint files and both are **accepted** after the dispatcher's own
verification (rebuild from a deleted `.olean`, token check, axiom footprints).  Neither file edits an
existing declaration; both are wired into `FinalCheck.lean` in this batch.

**P1 — `Definitions/MMFLM86ExpProduct.lean`** (349 lines, namespace `MM.FLM86EP`, 7 guards).
`creationExpVL_mul_comm` (a restatement of the strictly stronger landed
`MM.FLM84TV.creationExpVL_comm`, `MMFLM84TwoVarProduct.lean:624`); the concrete two-point product at
the lattice generators, `Yzero_iotaVL_mul_Yzero_iotaVL :
Yzero (iotaVL a) m * Yzero (iotaVL b) n = E.eps a b • (actVL E (a+b) * (creationExpVL a m * creationExpVL b n))`,
with the state form `Yzero_iotaVL_apply_iotaVL` ((8.5.11) at datum `p = 0`); and the commutator family
`commutatorFamily_Yzero_iotaVL = E.eps a b • X − E.eps b a • X`,
`…_eq_c : … = ((E.c a b − 1) * E.eps b a) • X`.

**P2 — `Definitions/MMFLM810CorrectedZeroAssembly.lean`** (299 lines, namespace `MM.FLM810CZA`, 7
guards).  The corrected Section 8.10 assembly line at `Yzero`: `componentTruncationZero` ((8.10.5) —
**reproved**, see below), `vacuumOperatorZero`/`creationRegularZero`/`creationPropertyZero`
((8.10.6)/(8.10.7), which cost only applications), and the two boundaries
`actionRemainingFieldsZero_of_generators`, `theorem8102_of_remainingFieldsZero`,
`theorem8102_of_generatorFieldsZero`.  `ActionRemainingFieldsZero` was **not created** — the landed
`MM.FLM810AFT.ActionRemainingFields` is about an arbitrary `VertexOp` and applies verbatim — and the
four generator reductions (`l0Grading_of_weightGenerators`, `translationAxiom_of_stateData`,
`virasoroAxiomsOf_of_stateData`, `jacobiAxiom_of_stateTargets`) also apply verbatim.

**Finding 1 — a wrong-prescription statement with a prescription-free proof.**  `MM.FLM85ATT`'s
`componentTruncation_action_modelBase` / `componentTruncation_of_actionPrescriptionTA` and
`MM.FLM810AFT`'s `vacuumOperator_action_modelBase` / `creationRegular_action_modelBase` /
`creationProperty_action_modelBase` all carry a compatibility hypothesis **for
`actionPrescriptionTA`**, although their proofs use only the underlying `TruncatedField` datum and its
factor list.  So they do **not** apply to `Yzero`, and `MMFLM810AFT`'s docstring — which calls them
fields "of the corrected object" — overstates what the statements say.  (8.10.5) had to be ported (~40
lines).  The bridges that *are* generic in the factor list (`MM.FLM85TAV.actionFold_vacuumNonnegative`,
`…_eq_cutOff`, `…_zero`) transferred with no work.

**Finding 2 — the zero mode is not the only defect, and the corrected field still fails (8.10.13).**
`MM.FLM810TR.not_translationOnStateData_modelBase`
(`Definitions/MMFLM810TranslationStateObstruction.lean:271`) proves, unconditionally, that
`TranslationOnStateData` is **false** for `vertexOpOfField (Yzero … (modelBaseField E weight))` at the
conformal vector whenever `(form a b : F) ≠ 0` and `actVL E a (iotaVL b) ≠ 0`.  So
`theorem8102_of_generatorFieldsZero` at that base is vacuous: **the obstruction is the
vacuum-supported (8.4.17) base field, not the missing `a(0)`.**  This corrects the batch's own opening
framing, and it means the construction carries **three** stacked defects, not one:

1. the missing (7.1.33)/(7.1.41) zero mode in `heisFam` — repaired by `heisFamZero`/`actionPrescriptionTAZero`/`Yzero`;
2. the missing grading shift `z^{a(0)}` in the base field — `Yzero`'s model base is creation-half only,
   and P1 measured the honest assembled (8.4.17) field `YFam` to be the model base **at a
   pairing-shifted index** (`Yzero_iotaVL_apply_iotaVL_eq_YFam`), which is the same shift seen from
   the other side;
3. the missing dictionary `MM.FLM8512H.ModeFamHeisShift` (`MMFLM8512Heis.lean:221`) identifying the
   prescription's factors `heisFam a m = modeVL a (−m−1)` with the field's modes
   `modeFam Y a m = Y (iotaVL a) (−m−1)` (`MMFLM8512Done.lean:403`) — a `Prop` with no producer.

**Consequence for the plan, and it is the point of the batch.**  The object the next tasks must be
stated about is **`MM.FLM84LF.YFam`** (`Definitions/MMFLM84LatticeField.lean:720`), the assembled
three-factor field `E^-(z)·(az^∂)·E^+(z)` of (8.4.17) — the only landed object that carries the shift
and the annihilation half — and **not** `Yzero` (creation half only) or `modelBaseField` (no shift).
P1's own `## What this file does not prove` block names the landed next steps: `fullPlus_contraction`,
`annihExp_mul_creationExpVL_eq_sum_of_subset` (with `ratioCoeff`/`ratioWindow`),
`YFam_iotaVL_eq_exp`, `Corollary851`, `Display8625One`.

**Also corrected in this batch's record**: `Yzero` is at `MMFLM810ZeroModeL0Uncond.lean:81` and
`Yzero_unique` at `:100` (the batch's own brief had `:82` and `:107`); the two batch-79 refutations are
`MM.FLM810MD.exists_not_l0OnWeightGenerators` (identity base) and
`MM.FLM810MD.exists_not_translationOnStateData` (counterexample base `translationTestBase`) in
`Definitions/MMFLM810ModesL0Trans.lean`, **not** at the (8.4.17) model base; and the corrected `hL0` of
the assembly boundary is already a theorem (`MM.FLM810ZMW.L0OnWeightGenerators_zero`,
`MMFLM810L0General.lean:301`), so that boundary needs only `hjac`/`htrans`/`hvir`.

**Dead ends, named so that no future batch re-dispatches them**: `IsHomogeneousOp` and everything
consuming it, `UniformBracketWindow` (`MMFLM86DisplayVOASplit.lean:80`), `Display8625`,
`CrossContraction` (`MMFLM86CrossContraction.lean:166`, refuted at `:392`), `Contraction8612Ratio`,
`ResidueUMulCompatibilityStatement`, `OperatorDisplay8620Statement`, `RelSpanningStatement`
(refuted `MMFLM85RelSpanning.lean:513`, superseded by the proved `PermSpanningStatement`), and
`MM.FLM86Q86.QuadrantResidueStateFree` (refuted `:526`).


---

### Batch 154 — **the honest field's two-point product is landed, and the swap symmetry is the way past its sign restriction**

**Q1 — `Definitions/MMFLM86YFamProduct.lean`** (351 lines, namespace `MM.FLM86YP`, 11 guards; verified
here by a rebuild from a deleted `.olean`, the token check, and the guards).  It attacks the two-point
product of the **honest** field `MM.FLM84LF.YFam` — the assembled (8.4.17) object carrying both the
grading shift `z^{a(0)}` and the annihilation half `E^+`, which batch 153 identified as the field the
remaining work must be stated about (not `Yzero`, which is creation-half only).

Landed: `YFam_mul_eq_twoVarField` (`YFam E a m * YFam E b n = twoVarField E a b (−m−1) (−n−1)`, the
bridge to the landed batch-147 two-variable carrier); `YFam_mul_eq_sum_ratioCoeff` and
`YFam_mul_eq_convWith2_contrFam` (the (8.4.22)/(8.4.25) expansion, `= convWith2 (normOrdered2 a b)
(contrFam ⟨a,b⟩) …`); `YFam_mul_YFam_iotaVL`/`_eq_exp` (the unconditional state form — the **inner**
factor evaluated on `ι(c)`, since **no landed lemma evaluates `YFam` on a general state**, which is the
file's first named residual); `contraction_coeff_eq_binom`
(`contrFam N (N−j) j = ((−1)^j · binomCoeff N j) • 1`, the coefficientwise `(z₁−z₂)^N`); and a
non-vacuity witness at `⟨1,−2⟩ = −2 < 0` (`YFam_mul_rankOne_negTwo_vacuum_ne_zero`).

**The restriction, measured, and it is a real one.**  `MM.FLM86PE.twoVarField_apply_eq_convWith2_contrFam`
(`Definitions/MMFLM86ProductExpansion.lean:462`) carries `hN : 0 ≤ form a b`: for `⟨a,b⟩ < 0` the
contraction family is not locally finite (`not_locallyFinite2_contrFam_of_neg`), every
`ratioCoeff ⟨a,b⟩ j` is nonzero, and the landed `MM.FLM86RX.threshold_holds` supplies only a
per-`(P,Q)`-per-state threshold, not an identity of operator families.  The brief's warning about this
was correct and the agent verified it rather than assuming it.

**The way past it, and the batch's second task.**  The product is symmetric under exchanging the two
states *and* the two variables: that swap carries `(a,b)` to `(b,a)`, whose pairing is the same number,
so the negative-pairing case **is** the positive-pairing case of the swapped pair.  The landed
`MM.FLM86TN.normOrdered2_swap` (`MMFLM86TwoVarNorm.lean:547`,
`swap2 (normOrdered2 E b a) = E.c b a • normOrdered2 E a b`) is exactly this statement for the
normal-ordered factor, and its three ingredient exchange laws are landed (`creationPair2_swap:451`,
`annihPair2_swap:457`, `midBlock2_swap2:464`, `swap2_convWith2:343`).  What is missing is the same
statement for `twoVarField` itself; task **R1** (`Definitions/MMFLM86TwoVarSwap.lean`) lands it and
transports the expansion along it, so that the `⟨a,b⟩ ≥ 0` restriction is removed in a named,
honest form.  **This is the classical resolution of the sign issue and it is bounded work** — it is
recorded here because the alternative reading ("the Leech lattice has negative pairings, so the
campaign is stuck") is wrong.

**Q2 — `Definitions/MMFLM86IterateIota.lean`** (349 lines, namespace `MM.FLM86II`, 6 guards; verified
here by a rebuild from a deleted `.olean` plus the token check).  It attacks the *other* side of
`MM.FLM85Co.Corollary851` — the iterate summands of (8.5.24) at the lattice generators, where FLM's
(8.5.11) is a theorem (`MM.FLM84LF.YFam_iotaVL`, `YFam_iotaVL_eq_exp`).  Landed:
`iterateStateFamily_lattice`, `iterateOf_lattice_eq_exp`, `iterateState_lattice_boundary`,
`iterateOf_lattice_boundary`, `bracketTerm_lattice`, `corollary851Residue_lattice`,
`stateFamilyStatement_lattice` (**this discharges, at a field carrying (8.5.2), a predicate
`MMFLMLatticeState.lean`'s header lists as open for a general vertex operator**),
`stateVanishesBelow_lattice`, `iterateOf_lattice_eq_zero_of_window`, `corollary851_lattice_iff`,
`Corollary851.canonical_lattice`, `iterateOf_lattice_boundary_ne_zero` (the threshold is **sharp**),
and (8.4.41)/(8.4.42) with every hypothesis discharged.

**The window at the lattice generators is the computed number `(−⟨a,b⟩).toNat`, with no (8.10.5)
hypothesis.**  `MM.FLM86UV.exists_iterate_uniform_vanishing` was checked and does **not** apply as-is
(its hypothesis is `ComponentTruncation` for the *whole* field, and it yields only `∃K`, not the
explicit threshold).

**The one hypothesis it had to carry, and it is a type fact rather than a gap in the mathematics.**
`iterateOf` consumes a **state-linear** map `Y : M →ₗ[F] CoefFamily F M`, whereas `YFam E a` is a
coefficient family; so the file carries the source's (8.5.2) as
`MM.FLM86II.YFamOnGenerators … Y := ∀ a, Y (iotaVL a) = YFam E a`.  **The dispatcher has since
identified a landed inhabitant**: with `base := MM.FLM85TAV.modelBaseField E weight`,
`MM.FLM810TC.Yzero_iotaVL_eq_modelBase` (`MMFLM810TranslationCorrected.lean:111`) gives
`Yzero (iotaVL a) = MM.FLM810F.modelBase E weight a`, and `modelBase` is by definition
`fun a => (latticeElement E a a w).YCoeff` (`MMFLM810Fields.lean:311`), which on a lattice generator
is exactly what `MM.FLM84LF.YFam_iotaVL` evaluates — so `Yzero` inhabits `YFamOnGenerators`.  Batch
155's task **S1** (`Definitions/MMFLM86YzeroIsYFam.lean`) lands that chain, which makes the whole
iterate side of Corollary 8.5.1 at the lattice generators unconditional.

**Which side is closed, exactly.**  The **RHS** (the residue) at the lattice generators is in closed
form for `⟨a,b⟩ ≥ 0` (residue `0`) and for `⟨a,b⟩ = −1` (`ε(a,b)·YFam E (a+b) (m+n)`), and its top
summand is closed for every pairing; for `⟨a,b⟩ ≤ −2` the lower summands need the outer evaluation
`Y(u_i)` at a Fock-descendant created state — the landed named gap
`MM.FLM85IS.CreatedStepResidual` / `MM.FLM86SF.Display8610List` (8.5.5)/(8.6.10), not landed and not
assumed.  The **LHS** is a defined expression in the assembled field alone
(`YFam E a m * YFam E b n − YFam E b n * YFam E a m`) but is not evaluated; that evaluation is the
two-point product Q1 addresses, and batch 155's task **S2** (`Definitions/MMFLM86CommIota.lean`)
assembles the commutator from Q1 plus the `z₁ ↔ z₂` swap of R1.

**Brief errors worth recording** (six, all measured by the agent): the namespace is `MM.FLM85It`
(neither `MM.FLM85Iterate` nor `MMFLM85It`); `iterateOf YFam a b i` is ill-typed (see above);
`YFam E a • (iotaVL b)` uses the wrong operation; `iterateComponent` is not a landed identifier (the
landed names are `MM.FLM85It.iterateOf` and `MM.FLM85Br.bracketTerm`); the vanishing lemmas used are
`MM.FLM85Co.StateVanishesBelow` / `MM.FLMLatSt.stateVanishesBelow_of_stateFamilyStatement`, not in
`FLM85It`; and the driver prints `--- OK: <path> ---`, not `--- OK ---`.

### Batch 155, part 1 — **`YFamOnGenerators` is REFUTED at `Yzero`: the dispatcher's own proposed identification was wrong, and the agent proved it**

Task S1 was dispatched to land the identification sketched in batch 154's entry — that
`MM.FLM810ZMU.Yzero` at the (8.4.17) model base inhabits the iterate side's hypothesis
`MM.FLM86II.YFamOnGenerators`, i.e. `∀ a, Y (iotaVL a) = YFam E a`.  **It came back with a
machine-checked refutation instead**, `Definitions/MMFLM86YzeroIsYFam.lean` (249 lines, namespace
`MM.FLM86YZF`, 8 guards; verified here by a rebuild from a deleted `.olean` plus the token check):

    not_YFamOnGenerators_modelBaseField (E) (weight) :
      ¬ YFamOnGenerators bL form E (Yzero bL form (modelBaseField E weight))

**The witness, and the root cause.**  `Yzero bL form base (iotaVL a) = (base a).fam` and the base is
`Yzero_iotaVL_eq_modelBase`'s `MM.FLM810F.modelBase E weight a`, i.e. `YCoeff` of the lattice element.
`YCoeff` is indexed by the **ordinary power** `z^m` ((8.4.20)/(8.4.24); `YCoeff m = 0` for `m < 0`),
whereas `YFam` is a **(8.5.15) `CoefFamily`**, whose index `m` is the coefficient of `z^{−m−1}`.  The
landed dictionary between the two conventions is `MM.FLM84TV.reflectFam A m = A (−m−1)`.  At the
index where the two are compared the values differ:
`(Yzero … (ι(0))) 0 (vacuumVL) = ι(0) ≠ 0` (`Yzero_iotaVL_zero_vacuum`) against
`YFam E 0 0 (vacuumVL) = 0` (`YFam_apply_zero_vacuum`, independently
`MM.FLM84LF.rankOne_YFam_zero_eq_zero`).  So this was never a missing lemma: **the two families are
different components**, and no choice of landed base puts `YFam E a` at `Yzero base (ι(a))`, because
the base interface `MM.FLM85TA.TruncatedField`/`ofNonnegative` is ordinary-power indexed.

**A second refutation, sharper.**  `not_iterateStateFamily_lattice_Yzero` shows the batch-154 *iterate
conclusion itself* is **false** at `Yzero`: `∀ a b i, (Yzero … (ι(a))) i (ι(b)) =
latticeState E a b ⟨a,b⟩ (−i−1)` fails at `i = 0`, `b = 0`, where it reads `iotaVL a = 0`.  So the 16
conditional results of `Definitions/MMFLM86IterateIota.lean` do not merely lack a witness — their
hypothesis is refuted at the only landed candidate, and **instantiating them at `Yzero` is impossible**.

**What survives, exactly (all landed in the same file, all sharp and conditional-free):**

* `Yzero_iotaVL_apply_iotaVL : (Yzero … (ι(a))) m (ι(c)) = YFam E a (−m−1−⟨a,c⟩) (ι(c))` — the true
  relation between the two: the `reflectFam` dictionary **composed with the state-dependent shift**
  `⟨a,c⟩` (the `z^{a(0)}` factor) and the `E^+` factor (which acts only off the vacuum sector).
* `Yzero_iterateStateFamily_latticeState : (Yzero … (ι(a))) i (ι(b)) = latticeState E a b ⟨a,b⟩ (i + ⟨a,b⟩)`.
* `Yzero_iotaVL_vacuum_eq_reflectFam` — on the **vacuum sector** the brief's identification *is* true
  through `reflectFam`, which is why the error was easy to make.

**The repair, named.**  The iterate hypothesis must be restated for the family the field actually
carries: `Y (ι(a)) = reflectFam (YFam E a)`, using the base
`fun a => ofNonnegative (reflectFam (YFam E a))` — whose lower-truncation datum `TruncatedField` is
owed (it should follow from `YFam_eq_zero_of_gt`, `MMFLM84LatticeField.lean:870`) — and then the whole
iterate machinery of `MMFLM86IterateIota.lean` becomes available with an inhabited hypothesis.  **This
is a change to batch 154's file, not to S1's**, and it is batch 156's first task.

**The meta-lesson, and it is the fifth of its kind in this campaign**: the dispatcher's brief asserted
an identification from three landed lemmas (`Yzero_iotaVL_eq_modelBase`, `modelBase = YCoeff`,
`YFam_iotaVL`) without checking the **index convention** of the two objects — the same class of error as
the `vacuity` of `IsHomogeneousOp` (batch 152) and the `RelSpanningStatement` retraction (batch 149),
and the reason `AGENTS.md` requires that a brief's key step be compiled before the brief is dispatched.
The agent measured the claim false instead of proving a false theorem, which is the outcome the
repository's rules ask for.

### Batch 155, part 2 — **the `z₁ ↔ z₂` swap does NOT remove the sign restriction, and the file as handed back does not build**

Task **R1** (`Definitions/MMFLM86TwoVarSwap.lean`, namespace `MM.FLM86TS`) was dispatched on the
dispatcher's own claim (recorded in batch 154's entry) that the `⟨a,b⟩ ≥ 0` restriction of the
(8.4.25) expansion is removable by the classical swap, "because exchanging the two states and the two
variables carries `(a,b)` to `(b,a)`, whose pairing is the same number".  **The premise is false, and
the agent refuted it machine-checked.**

**The correct exchange law, at `0 ≤ ⟨a,b⟩`, and it is not what the brief said.**
`MM.FLM86TS.twoVarField_swap2`:

    swap2 (twoVarField E b a) = (E.c b a * (-1)^⟨a,b⟩) • twoVarField E a b

— the cocycle **times the sign of the transported binomial**, not the cocycle alone.  (The sign comes
from `swap2_contrFam`, the swap of the contraction factor itself.)  With it,
`twoVarField_sub_swap2` gives the coefficientwise form of locality: the two orders differ by the
constant `1 − E.c b a · (−1)^⟨a,b⟩`, i.e. **the commutator is not a delta-function term in this
carrier** at `0 ≤ ⟨a,b⟩`.

**The restriction is NOT removed, and this is the batch's finding.**  §3 of the file is a rank-one
counterexample at `⟨a,b⟩ = −2 < 0` (`a = −2`, `b = 1`, `F = ℚ`, `L = ℤ`):

* `rankOne_swap2_twoVarField_negTwo_zero`: the exchanged product at `(m,k) = (0,−2)` on the vacuum is
  `ε(−2,1) • ι(−1) ≠ 0`;
* `rankOne_twoVarField_negTwo_zero_zero`: the un-exchanged product there is `0`;
* `not_swap2_twoVarField_rankOne (C)`: therefore `swap2 (twoVarField E (−2) 1) ≠ C • twoVarField E 1 (−2)`
  for **every** `C : ℚ`; `not_exists_swap_factor_rankOne` is the existential form.  **No constant factor
  whatsoever** — not the brief's `E.c b a`, not the corrected `E.c b a · (−1)^⟨a,b⟩` — makes the
  exchange law hold at negative pairing.

**Why the premise fails, in one sentence.**  The swap exchanges the two states *and* the two variables
at once, so it compares the two different *expansion orders* of the same rational function; at
`⟨a,b⟩ < 0` the contraction factor is a genuine series rather than the polynomial `contrFam`
(which is why `locallyFinite2_contrFam` needs `0 ≤ ⟨a,b⟩`), and the two expansion orders are not
related by a constant at the coefficient level.  This is the same phenomenon the repository already
records for the two residue faces of the Jacobi identity
(`MM.FLM810Route.res_z1_face_swap`, `Definitions/MMFLM810JacobiRoute.lean`), now measured on the
product itself.

**A dispatcher measurement that was right about a state of the file and wrong about the file.**
The dispatcher rebuilt the file while the agent was still rewriting it and hit

    Definitions/MMFLM86TwoVarSwap.lean:216:0: error: (deterministic) timeout at `whnf`,
    maximum number of heartbeats (400000) has been reached

for `twoVarField_swap2`, cascading to `unknown constant 'MM.FLM86TS.twoVarField_swap2'` and three
`#guard_msgs` mismatches, one printing the self-referential footprint
`[propext, Classical.choice, Quot.sound, twoVarField_sub_swap2]`; raising the budget to `2000000`
heartbeats did not help either.  **The final file is 315 lines, builds in 2.3 seconds and passes its
guards**, and the agent's own measured advice explains the difference: a `convWith2`-level proof of the
exchange law — `rw` with `convWith2_congr`, or `simpa using congrFun (congrFun …)`, which drags the
`LocallyFinite2` **proof terms** through the whole term — exceeds 2 000 000 heartbeats, while the
**pointwise `Finset.range` route** (state-level expansion plus `Finset.sum_range_reflect`) elaborates
in seconds.  The dispatcher's verdict is therefore corrected in place: the earlier claim that the file
"does not build" described a mid-edit revision, not the deliverable.  **The lesson that survives is the
one worth keeping**: a rebuild by the dispatcher must be run against a *settled* file — and the agent,
for its part, must not leave the tree in a state where the dispatcher cannot tell.
The landed `MM.FLM86TN.convWith2_proof_irrel` (`Definitions/MMFLM86TwoVarNorm.lean:238`) is available
for any future proof that genuinely needs to rewrite under `convWith2`.

### Batch 156 — four fronts opened toward Theorem 8.10.2

Owner's directive: continue without check-ins until **Theorem 8.10.2** (that `V_L` is a vertex operator
algebra) is complete.  The corrected assembly line is already landed
(`MM.FLM810CZA.theorem8102_of_generatorFieldsZero`, batch 153), so what Theorem 8.10.2 needs is the
**four fields** for the right field: Jacobi (8.10.8), `L0` (8.10.12), translation (8.10.13) and
Virasoro (8.10.9) — plus, for the full Jacobi identity, the rationality layer of §8.10.  Four tasks were
dispatched on disjoint files:

* **T1 `Definitions/MMFLM86GenFamTrunc.lean`** (`MM.FLM86GT`) — restate the iterate hypothesis in the
  indexing the field actually carries (`Y (ι(a)) = reflectFam (YFam E a)`, base
  `ofNonnegative (reflectFam (YFam E a))`, lower truncation from `YFam_eq_zero_of_gt`), and prove that
  restated hypothesis **inhabited** by the unique extension of the corrected prescription.  This is
  what makes batch 154's iterate side usable again after
  `MM.FLM86YZF.not_YFamOnGenerators_modelBaseField` killed its original hypothesis.
* **T2 `Definitions/MMFLM86CommIota.lean`** (`MM.FLM86CI`) — the **left-hand side** of Corollary 8.5.1
  at the lattice generators: the commutator family as an explicit two-variable expression, in closed
  form at `0 ≤ ⟨a,b⟩` via the batch-155 exchange law `twoVarField_swap2`/`twoVarField_sub_swap2`, and
  the sharpest supportable statement at negative pairing (the `TwoVar` carrier cannot express
  `contrFam N` for `N < 0`).
* **U1 `Definitions/MMFLMIotaVar.lean`** (`MM.FLMIotaVar`) — FLM (8.10.36)–(8.10.42), the
  **several-variable `ι` maps**, which do not exist in the repository and are the prerequisite of
  **every** `l ≠ 0` face of the Jacobi identity: Prop. 8.10.3–8.10.5 and Prop. 8.10.7 are all stated in
  that language.  The `n = 1` case is landed in `Definitions/MMFLMLocalization.lean` (§1–§3, with
  `iotaOne_eq_iotaPlus` identifying it with `MM.FLM81.iotaPlus`); the recursive step (8.10.40)/(8.10.41)
  is not.  The brief asks for a precise `n = 2` file over a half-finished general one.
* **V1 `Definitions/MMFLM86CreatedStep.lean`** (`MM.FLM86CS`) — the **created-state step**: extend the
  proved lowest case (`MM.FLM85IS.iterateProductStepLevelAt_zero_created_nil_componentField`, i.e.
  (8.5.23) at `l = []`, `j = 0`) to every coefficient `j`, then to the first non-vacuum created state
  `l = [x]`.  `CreatedStepResidual` is **equivalent** to the display
  (`createdStepResidual_iff_display8610List`), so this is on the critical path and is not a weakening —
  the brief says so explicitly to prevent the obvious circularity.

**Process note for this batch, and it is a risk taken knowingly**: four agents were launched at once,
and `AGENTS.md`'s build-hygiene rule is that concurrency is limited by **memory** (≈4.2 GB per `lean`
process) and that two concurrent builds "manufacture fake timeouts".  A serialising build lock
(flock on a lock file in `Probe/`) is the right fix and is recorded here as the next process
improvement; the batch is being watched for timeouts that are artefacts rather than real failures.

**T2 ACCEPTED — `Definitions/MMFLM86CommIota.lean`** (421 lines, namespace `MM.FLM86CI`, 12 guards;
verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  The left-hand side of Corollary 8.5.1 at the lattice
generators is now in closed form, and the batch produced **two** results that change the map.

**(a) The commutator vanishes at the intended cocycle, unconditionally.**
`commutator_YFam_eq_twoVarField_sub_swap2` expresses the commutator through
`twoVarField a b − swap2 (twoVarField b a)` for **every** pairing (no sign hypothesis), and
`commutator_YFam_eq_smul_mul_of_nonneg` makes the `0 ≤ ⟨a,b⟩` case explicit: the commutator is the
**constant** `1 − E.c b a · (−1)^⟨a,b⟩` times the product — **no delta term** in this carrier.  The new
mathematical content is `evenCocycle_c_mul_neg_one_zpow`: for the source's own even-lattice cocycle
`MM.FLMLattice.EvenCocycle` (from `C.c_eq_signPow`), that constant is **zero**:

    (C.toCentralExtension h2).c b a * (-1)^(form a b) = 1        (h2 : (2 : F) ≠ 0, form symmetric)

hence `commutator_YFam_eq_zero_of_even`: at the honest fields and the intended cocycle,
`[YFam a m, YFam b n] = 0` for `0 ≤ ⟨a,b⟩`, with **no `hY` and no `h851`**.  *This is the compatibility
`c(a,b) = (−1)^⟨a,b⟩` that the landed `CentralExtension` does not assume and `EvenCocycle` supplies —
and it is exactly the hypothesis Theorem 8.6.1's (8.6.1) is stated under.*

**(b) The batch-154 iterate-side headline is vacuous at the landed rank-one datum, and this is now a
theorem.**  `not_YFamOnGenerators_and_corollary851_rankOne` refutes `hY ∧ h851` at the rank-one datum
with `a = b = 1`: there `⟨1,1⟩ = 1 ≥ 0`, the constant is `1 − c(1,1)(−1)^1 = 2 ≠ 0` for the trivial
cocycle, and the product is nonzero on the vacuum (`YFam 1 (−2)(YFam 1 (−1) vac) = ε(1,1)•ι(2)`), so
`(hY, h851)` would force `2 • (nonzero) = 0`.  Consequently
`MM.FLM86II.commutatorFamily_lattice_eq_zero_of_nonneg` is **not** "the `0 ≤ ⟨a,b⟩` case of (8.4.41)"
in landed generality: its hypothesis pair is empty at that datum.  The regression the brief asked for
therefore *failed*, in the useful direction — and the failure isolates the cocycle/form compatibility as
the real dividing line, rather than the pairing's sign alone.

**(c) The missing range is now exactly `⟨a,b⟩ ≤ −2`.**  For `N < 0` the contraction family is not
locally finite, so `convWith2` has no instance: no finite coefficient expansion of (8.4.25) exists in
this carrier.  The exchange law is false there (`MM.FLM86TS.not_swap2_twoVarField_rankOne`) and the
commutator is genuinely nonzero (`commutator_rankOne_negTwo_ne_zero`:
`−ε(1,−2) • ι(−1)` at `(a,b) = (1,−2)`, `(m,n) = (−1,1)`, vacuum).  So the negative-pairing case is
**not** a defect of the formalization — it is a real phenomenon that the finite-support carrier cannot
express, and the only route to it is the residue sum of (8.5.13) itself, i.e. `Corollary851` with its
outer evaluation at the created states (the `CreatedStepResidual`/(8.6.10) gap that task V1 is
attacking).  `⟨a,b⟩ = −1` **is** in closed form (8.4.42), but only under `hY ∧ h851`.

**Where Theorem 8.10.2 now stands, field by field** (updated in batch 156, and this is the ledger entry
that matters for the remaining work):

| field | status |
| --- | --- |
| (8.10.5) truncation | **proved** for `Yzero` (`MM.FLM810CZA.componentTruncationZero`); |
| (8.10.6) vacuum, (8.10.7) both creation halves | **proved** for `Yzero` (`vacuumOperatorZero`, `creationRegularZero`, `creationPropertyZero`); |
| **(8.10.12) `L0` grading** | **PROVED** — `MM.FLM810ZMW.LOf_conformalVectorZero_on_weightPiece` (`MMFLM810L0General.lean:273`) and `L0OnWeightGenerators_zero` (`:301`), from `hnd`, symmetry of `form` and `(base 0).fam = identityField`.  **This is not an open field**, contrary to the batch-153 reading; |
| **(8.10.13) translation** | **false at the model base** (`MM.FLM810TR.not_translationOnStateData_modelBase`); the repaired base (`reflectFam`-indexed) is being tested by task W1; |
| **(8.10.9) Virasoro** | reduced, conditionally, to **two named `Prop`s** by `MM.FLM87ZBC.virasoroOnStateData_of_named` (`MMFLM87ZeroModeBracketClose.lean:129`): `MM.FLM87ZB.sugawaraModeZero_eq_fockSugawaraVLZero` and `MM.FLM87ZB.fockSugawaraVLZeroBracket`, whose honest form is `MM.FLM87SA.FreeBosonSugawaraBracketZero` (`MMFLM87SugawaraAux.lean:218`) — FLM (8.7.9) for the corrected modes, the paper's `L(n)` bracket.  Its header records that it is **not refuted**: it is about the honest inverse-Gram Sugawara vector; |
| **(8.10.8) Jacobi** | **open**, and the only field with no landed reduction to a finite list.  The `Res_{z₀}` face is Theorem 8.6.1's display (batch 152); the `l ≠ 0` faces need the several-variable `ι` maps (task U1) and the rationality propositions (8.10.3)–(8.10.7); the `l = 0` face at negative pairing needs a carrier that can express a contraction series. |

So the remaining work for Theorem 8.10.2 is **translation + Virasoro + Jacobi**, and each of the three
now has either a landed reduction (Virasoro: two named `Prop`s; translation: the base repair) or a
named infrastructure prerequisite (Jacobi: U1's `ι` maps).  `L0` is done.

**U1 ACCEPTED — `Definitions/MMFLMIotaVar.lean`** (852 lines, namespace `MM.FLMIotaVar`, 7 guards;
verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  FLM (8.10.37)–(8.10.42) now exist in the repository
for `n = 2`, and they did not exist at all before this batch: the `l ≠ 0` faces of the Jacobi identity
were blocked on exactly this.

**The carrier decision, which is the batch's structural finding.**  FLM's `F[[z_1,z_1^{-1},z_2,z_2^{-1}]]`
is **not a ring in FLM's use**: the landed `no_ringHom_monomial` shows no ring homomorphism into the
product model can send `z_1 − z_2` to a unit, although `z_1 − z_2 ∈ S` by (8.10.36) and the localisation
`F[z_1,z_2]_S` inverts it.  So `ι` is honestly an **`F`-linear map into the product space** (FLM's own
target), while each *ordering* does live in a ring: expanding first in negative powers of `z_{i_1}` makes
the outer exponents well-founded (`OrderDual ℤ`), and the inner ones are Laurent.  Hence the carrier
`IotaVar F := HahnSeries (OrderDual ℤ) (HahnSeries ℤ F)` (a field), with two variable assignments and
**both** incarnations landed: ring homs `iota12Ring`/`iota21Ring` into the carrier, and the `F`-linear
`iota12`/`iota21` into FLM's target `AllSeriesN F 2`, which is what Prop. 8.10.3–8.10.5 consume.

**Landed**: `innerEmbed` (= the landed `polyToSeriesOne`) with injectivity; `polyToOnePoly_injective`
(proved here — the landed file lacked it); `outerEval` with its support formula and injectivity;
`emb12`/`emb21` with injectivity and generator values; `iota12Ring`/`iota21Ring` via `IsLocalization.lift`
with `iota{12,21}Ring_algebraMap` and injectivity; `invX`; the values of both readings on the five
generators `z_1, z_2, z_1−z_2, z_1^{-1}, z_2^{-1}`; and the series
`invSeries = Σ_{m≥0} z_2^m z_1^{−m−1}` with `mul_invSeries` (telescoping), `iota12_invShift = expand12`,
`iota21_invShift = expand21`, `iota12_sub_iota21_invShift = deltaRatio`,
`shift_iota12_invShift`, and `iota12_invShift_ne_iota21_invShift`.

**Injectivity is proved, not assumed** (the source's "it is clear that the maps `ι_{i_1⋯i_n}` are
injective"), at all three levels: the polynomial embeddings, the ring homs out of the localisation
(`IsLocalization.lift_injective_iff` plus `IsLocalization.injective` with the landed
`S_le_nonZeroDivisors`), and the readings.  Given that the repository's `MM.FLM81.KerThetaStatement`
exists precisely because such statements can fail, this is worth recording as a proved item rather
than a citation.

**The sharp negative fact that bounds what the `l ≠ 0` faces can say.**  The delta series is supported on
the whole antidiagonal — unbounded above in the outer exponent — so it is **not an element of the
carrier**: the difference of the two expansions exists only in FLM's target, while in the carrier the two
elements differ by a sign (`± invSeries`).  This is the `n = 2` form of FLM's Remark 8.10.1, and it is the
same phenomenon batch 155 measured on the product (the two expansion orders are not related by a
constant), now located in the `ι` language and given a carrier.

**What the file does not prove** (its own `## What this file does not prove`): general `n`; FLM's
(8.10.41) partial-fraction form of the recursion; the *general* delta statement — which needs the landed
but unproved (8.1.9) `MM.FLM81.ThetaShiftStatement` — beyond the `f = (z_1−z_2)^{-1}` case and the five
generators; (8.10.45) beyond generators; the kernel characterisation; and any VOA content.  The brief's
own claim that "the two expansions agree exactly on Laurent polynomials" is `n = 1` only; for `n = 2` the
landed fact is the opposite (`expand12 ≠ expand21`), and this is recorded as a brief error.

**V1 ACCEPTED — `Definitions/MMFLM86CreatedStep.lean`** (254 lines, namespace `MM.FLM86CS`, 4 guards;
verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  It was dispatched to extend the proved lowest case of
the created-state step to every coefficient `j`, and it came back with a **refutation** instead — the
fourth appearance of the same defect.

* **Landed**: `zeroFactorLevel_zero_componentField`, the `j = 0` level of (8.5.12)/(8.5.23) at
  `iteratedCreation _ _ []` — batch 123's theorem restated at this interface.
* **Refuted**: `not_modelBasePositiveModesKillVacuum` at the landed model base (rank one,
  `F = ℚ`, `L = ℤ`, trivial cocycle), from the unconditional
  `rankOne_component_neg_two_ne_zero : (componentField (Yzero … (modelBaseField …))) (iotaVL 1) (−2) vacuumVL ≠ 0`.
  **Mechanism**: the landed base is `YCoeff = E^-(z)·(a z^∂)` — creation half only — so its positive
  modes are `actVL E a * creationExpVL a m`, and batch 133's `creationExpVL_ne_zero`
  (`MM.FLM85FS`) makes them non-vanishing on `ι(1)` at **every** `m ≥ 0`.  Hence FLM (8.10.7) fails at
  the model base, and no §8.5 normal-ordering computation can repair it: **the missing factor is the
  annihilation half `E^+` of (8.4.17)**, exactly as `MMFLMY87.lean`'s header records.
* `PositiveModesKillVacuum` / `ModelBasePositiveModesKillVacuum` / `CreatedStepResidualLevels` name the
  residual exactly.
* Two brief errors of record: the level is **not** vacuous at `j ≥ 1` — its right-hand side is
  `conv (shiftedField Y a j) A`, which is `1` at `A = vacuumField` and `0` at `A = 0`, so it carries
  content at every `j` — and target 2 (`l = [x]`) is target 1 one step out
  (`iterateAt_singleton_reduce` is `rfl`), hence refuted wherever target 1 is.

**This is now the decisive convergence of batch 156**: W1 (translation at the repaired base), T1 (the
iterate hypothesis at the `reflectFam`-indexed base) and V1 (the created-state step) have independently
arrived at the **same** repair — the base field of the (8.5.5) prescription must be the honest assembled
(8.4.17) family `MM.FLM84LF.YFam`, with its `z^{a(0)}` shift and its `E^+` half, rather than the landed
`YCoeff`/`modelBase` which has neither.  Three separate fields of Theorem 8.10.2 (translation, the Fock
half of (8.10.7), and the created-state step) fail at the old base and are expected to hold at the new
one.

**W1 ACCEPTED — `Definitions/MMFLM810TranslationBase.lean`** (438 lines, namespace `MM.FLM810TB`, 5
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`, all 20 declarations at
`[propext, Classical.choice, Quot.sound]`).  It was dispatched to test the dispatcher's own
"`reflectFam`-indexed base" repair for (8.10.13), and it **corrected the diagnosis** while landing the
right object.

**Landed.**  `baseRepaired (E) : L → TruncatedField F L` with `fam := reflectFam (YFam E a)` — the honest
(8.4.17) assembled field in the ordinary-power convention — its `trunc` from
`MM.FLM84LF.YFam_eq_zero_of_gt`, its unfolding `baseRepaired_fam`, and
`baseRepaired_zero : (baseRepaired E 0).fam = FLM84.identityField` (8.5.3), with the factor-level chain
that gets there.  `l0OnWeightGenerators_baseRepaired` gives the `L0` field at it from `hnd` and symmetry
of `form` alone.

**The verdict on (8.10.13) at the repaired base is a reduction, not a verdict — and it is sharp.**
`translationOnStateData_baseRepaired_base_state_iff`: for every `a` and `p`, the component `m = −p−1` of
`TranslationOnStateData` at `D = ⟨[], a⟩` is **equivalent** to the honest (8.4.23) at the honest family,

    (actionFold [heisFactor a] (baseRepaired E a)).fam p = deriv (baseRepaired E a).fam p

and `translationOnStateData_baseRepaired_forces_deriv` is the one-way whole-predicate form.  So the
repair **removes the model base's obstruction** — the (8.4.16) creation half is nonempty there, and the
tail at `p = −1`, `⟨a,c⟩ = −1` is `actVL E a (α_a(−1)ι(c)) = ε(a,c)·α_a(−1)ι(a+c)` by the landed
`actVL_modeVL_comm` — but it does **not** close (8.10.13): the residual is the honest (8.4.23)
`deriv (YFam E a) = 8α_a(z)Y(a,z)8`, which is **not landed** (the landed (8.4.23) is the model-base
identity, shown by `MM.FLM810TC.deriv_modelBase_ne_flat_add_tail` to be the creation half alone).
Oscillator states `D` with `k ≥ 1` are untouched.

**The diagnosis is corrected, and the correction matters.**  The dispatcher had claimed the model base was
`reflectFam (YFam E a)` mis-indexed, i.e. a pure indexing artefact.  **False**: `modelBase = gOp·E^-` is
the *vacuum-sector/flat* model of (8.4.17), missing the middle `a z^∂` and the `E^+` half; it agrees with
the honest family only on the vacuum sector (`YFam_vacuumVL_eq_YCoeff`) and differs as a family —
`baseRepaired_ne_modelBase`, a landed witness.  Also corrected: `ofNonnegative (reflectFam (YFam E a))`
does **not** typecheck (the honest family has genuine negative powers, bounded below only), so the
`TruncatedField` was built directly; `Yzero_iotaVL_apply_iotaVL` is `MM.FLM86EP.*`
(`MMFLM86ExpProduct.lean:209`), not `FLM86YZF`; the landed model-base refutation carries two explicit
nonvanishing hypotheses, so "unconditionally false" was an overstatement; and `L0` does not test the
repair at all, since `L0OnWeightGenerators_zero` takes `(base 0).fam = identityField` as a hypothesis and
holds for an arbitrary base.

**Batch 156's convergence, now with the correct content**: W1, T1 and V1 agree that the base must be the
honest `YFam` family — but W1 shows that this repair is a *reduction to the honest (8.4.23)*, not a
discharge of translation.  The next task on this front is therefore **the honest (8.4.23) at `YFam`**
(`deriv (YFam E a) = 8α_a(z)Y(a,z)8`), which is a concrete landed-target computation on the assembled
three-factor field.

**T1 (in flight) — the key finding, and it is a Lean trap, not a mathematical one.**  Task T1
(`Definitions/MMFLM86GenFamTrunc.lean`) has confirmed the mathematics of the repair: `genFam E a m =
YFam E a (−m−1)` is the correct reindexing, and the restated hypothesis **is inhabited** by `Yzero` at
the base `fun a => ofNonnegative (genFam E a) hgen`, because
`actionPrescriptionTAZero base ⟨[], a⟩ = actionFold [] (base a) = base a` and
`stateOfVL ⟨[], a⟩ = iotaVL a` are both `rfl`, so the uniqueness statement of
`MM.FLM85ZP.existsUnique_actionPrescriptionTAZero` applies with **no** hypothesis failing.

The prerequisite `hgen : ∀ m < 0, genFam E a m = 0` reduces to the **sharpened** statement
`YFam E a k = 0` for all `k ≥ 0` — which is **not** the landed one-sided
`MM.FLM84LF.YFam_eq_zero_of_gt` (`:870`, vanishing *above* a bound), and is not landed anywhere.  The
agent reduced it to a complete proof shape (`annihFam` is supported at the single index `−1`,
`annihFam_eq_ite`, so `YFam E a m v = convWith creationFam midFam hB m v`, and the support set of
`z^{a(0)}` can be taken involution-closed so that each summand vanishes), and every step compiled except
the final arithmetic.

**The blocker is `omega`, and it is now recorded in `AGENTS.md` as the most expensive trap in this
pin.**  `omega` **silently drops** linear `ℤ` hypotheses and goals containing subtraction, unary
negation or a numeral offset: `example (j : ℤ) (h : (0:ℤ) < j + 1) : (0:ℤ) < j := by omega` reports
*"No usable constraints found"*, and `linarith` fails it too.  It succeeds when the goal is
syntactically a hypothesis or when no negation/offset occurs.  The workaround is to hand-build the
`Int` chain or restate the arithmetic; **do not conclude a goal is unprovable from an `omega`
failure.**  Also recorded there: `Finset.mem_of_eq`, `lt_of_not_le` and `Int.lt_of_le_of_ne` do not
exist in this pin, and `MM.FLM85TA.TruncatedField`/`ofNonnegative` live in
`Definitions/MMFLM85TrueAction.lean` — a file name that does **not** match its namespace, so a `grep`
for the namespace in file *names* finds nothing.

**T1 CLOSED, NOT LANDED — and the repair it was testing does not work: the honest field has genuine poles.**
Task T1 was to restate the iterate hypothesis in the indexing the field carries, with the base
`fun a => MM.FLM85TA.ofNonnegative (genFam E a) hgen` where `genFam E a m = YFam E a (−m−1)`
(`Definitions/MMFLM85TrueAction.lean:38`/`:151`, **not** a `MMFLM85TA*.lean` file).  It landed no file:
the prerequisite `hgen : ∀ m < 0, genFam E a m = 0` — equivalently `YFam E a k = 0` for **all** `k ≥ 0` —
resisted, and the dispatcher's own reading of the landed value lemmas says why.

**The prerequisite is false, and the reason is structural.**  `MM.FLM84LF.YFam_iotaVL` (`:770`) gives
`YFam E a m (ι(c)) = latticeState E a c ⟨a,c⟩ (−m−1)`, and `latticeState` is, by its definition
(`Definitions/MMFLMLatticeState.lean:391`),
`actVL E a (creationExpVL a (m − p) (actVL E c ω))` — i.e. a coefficient of the creation exponential
**shifted by the exponent `p = ⟨a,c⟩`**.  At `m = 0`, `c = 0` this is the constant term of
`creationExpVL`, which is `1` (`creationExpVL_zero`), so

    YFam E a 0 (vacuumVL) = actVL E a (vacuumVL) = iotaVL a  ≠ 0

(`actVL_vacuumVL`), whereas the prerequisite demands `0`.  The same computation at `c = a` reads
`YFam E a 0 (ι(a)) = E.eps a a • ι(2a) = iotaVL (2a) ≠ 0`.  So **no** choice of landed base puts a
nonnegatively-supported family at `Yzero base (ι(a))` — the honest (8.4.17) field is bounded below but
genuinely carries negative powers of `z`, which is exactly why the FLM (8.5.5) prescription has to
accept a **negative lower bound**, i.e. why `MM.FLM85TA.TruncatedField` is a *lower truncation* datum
rather than a nonnegativity datum.

**A second brief error, of the same class as the batch-155 refutation.**  The brief suggested deriving
`m < 0 → genFam E a m = 0` from the landed `MM.FLM84LF.YFam_eq_zero_of_gt` (`:870`).  That lemma is
**one-sided** — it vanishes *above* a bound, index → +∞ — and says nothing about vanishing at
nonnegative indices.  This is the fourth brief in this campaign whose key step was asserted without
compiling it, and the agent was right to refuse to write a file around it.

**What T1 did settle, and it is worth keeping.**  `MM.FLM85ZP.existsUnique_actionPrescriptionTAZero` is
stated for an **arbitrary** base, so it applies verbatim to any base of the shape above; and the chain
`Yzero_spec base ⟨[], a⟩` → `stateOfVL ⟨[], a⟩ = iotaVL a` → `actionPrescriptionTAZero base ⟨[], a⟩ =
actionFold [] (base a) = base a` is **definitional** at every step.  So the *machinery* for restating the
iterate hypothesis works; what fails is the choice of `genFam` as the base.

**The direction this leaves for the iterate side.**  Since the honest field's lower bound is negative,
the base interface must be fed a lower-truncated family with a genuinely negative bound (or the
prescription must be restated over a two-sided indexing).  That is a change to the *interface*, not to
the iterate machinery, and it is recorded here rather than attempted again with the same brief.

**CORRECTION OF RECORD (dispatcher, batch 156 close).**  The entry above retracting the `genFam` base
repair is **wrong in its main claim**, and the primary source settles it.  FLM printed 198, (8.5.1) and
(8.5.8), quoted verbatim from the page image:

    8.5.1  the correspondence iota(a) -> Y(a,z) for a in L extends uniquely to a well-defined linear map
    8.5.8  lim_{z->0} Y(u,z) iota(1) = u,  "Here of course the limit has algebraic meaning because
           Y(u,z) iota(1) involves only nonnegative integral powers of z."

So **the base field of (8.5.5) must vanish at every negative exponent**, and the honest assembled field
`MM.FLM84LF.YFam` — being the restriction of the general vertex operator to the lattice states — is
exactly the object the base must be.  The dispatcher's "refutation" computed `YFam E a 0` by composing
the three factors in the **wrong order**: `convCoef` is `Σ_j A (m−1−j) (B j w)`, so with `YFam =
convWith (convWith creationFam midFam) annihFam` the outer application is `creationFam … ∘ annihFam`,
and at `m = 0` the term is `creationFam a 0 (midFam a (−1) (annihFam a (−2) ω))`.  The correct
verification of the truncation is therefore **task T1's own proof shape**, which reduced it to
`∀ m < 0, genFam E a m = 0` via an involution-closed support argument and failed only on the `omega`
arithmetic trap — not on mathematics.  `Definitions/MMFLM86GenFamTrunc.lean` is **not** refuted and
should be re-dispatched, with the `omega` workaround budgeted explicitly (see `AGENTS.md`).

*The meta-lesson, and it is the fifth of its kind in this campaign: the dispatcher computed a value by
hand from three landed lemmas and did not compile it.  A hand computation is a hypothesis exactly as a
brief's claimed route is.*

---

### Batch 157 — **the owner's directive: align the definitions with the book first, then prove Theorem 8.10.2**

Owner's instruction (2026-09-20, before leaving the session): *"do the definitional alignment first,
otherwise all we do is waste compute proving things false; I want a proof of Theorem 8.10.2, and the
alignment must follow the book."*  The goal is re-stated accordingly (revision 5): **align, then
prove**.

**The alignment audit, with the source quoted (`Probe/FLM_8p4_8p5_quoted.txt`, PDF pages 244--258 =
printed 189--203):**

| # | the book | the repository | verdict |
| --- | --- | --- | --- |
| 1 | **(8.4.7)** `a(z) = Σ_{n∈ℤ} a(n) z^{−n−1} = z^{−1}a^old(z)` — the sum runs over **all** of `ℤ`, and (8.4.13)/(8.4.14) put `a(0)` in the normal ordering | `MM.FLM85Cp.heisFam a m = modeVL a (−m−1)` (`MMFLM85Compat.lean:213`), and `modeVL a 0 = 0` (`Definitions/MMFLMLatticeModule.lean:796` composed with `MM.FLM84.mode_zero`, `MMFLMFock.lean:398`) | **zero mode missing** |
| 2 | **(8.4.17)** `Y(a,z) = 8e^{∫(a(z)−a(0)z^{−1})} a z^∂8 = X(a,z) z^{−(a,a)/2}` — **three** factors | the assembly's base `MM.FLM810F.modelBase E w` (`MMFLM810Fields.lean:311`) is `(latticeElement …).YCoeff = gOp · E^−` — the **creation half only** | **`a z^∂` and `E^+` missing** |
| 3 | **(8.5.1)** the correspondence `ι(a) ↦ Y(a,z)` extends **uniquely**; **(8.5.8)** `lim_{z→0} Y(u,z)ι(1) = u`, "because `Y(u,z)ι(1)` involves only nonnegative integral powers of `z`" | the base interface `MM.FLM85TA.TruncatedField`/`ofNonnegative` (`MMFLM85TrueAction.lean:38`, `:151`) demands vanishing below `0`, but no landed theorem says the honest base satisfies it | **never proved** |

**The correction of record that this audit forced.**  Batch 156's closing entry had retracted the
`genFam` base repair as "refuted".  **That retraction is itself wrong**, and (8.5.8) is why: the base
field *must* vanish at negative exponents, and the honest `YFam` does.  The dispatcher's hand
computation that produced the "refutation" composed the three factors in the wrong order —
`convCoef A B hB m w = Σ_j A (m−1−j) (B j w)` (`MMFLM85ConvProduct.lean:256`) applies **`B` first** —
and T1's own proof shape (involution-closed support of `z^{a(0)}`) was right; it failed only on the
`omega` trap.  Both the false refutation and its correction are now in the record.

**Batch 157 tasks (dispatched):**

* **D0 — reconnaissance** (`Probe/B157_D0_IMPACT.md`): the migration impact map — every consumer of
  `heisFam`, `modeVL`, `modelBase`, `YCoeff`, `TruncatedField`, `ofNonnegative`, classified as
  definition site / proof consumer / doc-comment only, with the theorems that would become **false**
  under the alignment identified by name (that set is the migration's cost), the already-landed repaired
  layer (`MM.FLM85ZM.*`, `MM.FLM85ZP.*`, `MM.FLM810ZM*`, `MM.FLM810ZMU.*`, `MM.FLM84LF.*`) listed, and a
  dependency-ordered migration plan.
* **D1 — proof** (`Definitions/MMFLM85BaseFieldAligned.lean`, namespace `MM.FLM85BA`): alignment step 1,
  the base field as the book defines it — `genFam E a m := YFam E a (−m−1)`, **the lower truncation
  (8.5.8) as a theorem** (`∀ m < 0, genFam E a m = 0`, the lemma task T1 could not finish), the
  `TruncatedField` package `baseAligned`, its identity at `a = 0` (8.5.3), and the inhabitance of the
  restated generator hypothesis by `Yaligned := Yzero (baseAligned E)`.  The brief carries the `omega`
  workaround explicitly.
* **X1 — proof** (`Definitions/MMFLM84DerivYFam.lean`, namespace `MM.FLM84DY`, in flight from batch
  156): the honest (8.4.23) `deriv (YFam E a) = 8α_a(z)Y(a,z)8`, which stands on the correct field
  already and is the residual of translation (8.10.13).

**Standing rules for the rest of this campaign, restated so that any later batch can be audited against
them:** every brief's key step is a hypothesis until compiled; every handed-back file is rebuilt by the
dispatcher from a deleted `.olean` before acceptance; every negative report is re-measured before it is
believed; and every claim that turns out false is corrected **in place** in this ledger rather than
quietly dropped.

**D0 ACCEPTED — `Probe/B157_D0_IMPACT.md` (410 lines)**; the dispatcher verified its two structural
claims against the sources before acting on them.

**Correction to this batch's own audit, and it is good news.**  Batch 157's table above listed the base
interface as a deviation ("the base interface requires vanishing below `0`").  **That is only half
right**, and D0 measured it: `MM.FLM85TA.TruncatedField` (`Definitions/MMFLM85TrueAction.lean:38`)
requires **lower truncation only** —

    trunc : ∀ (w : VL F L) (m : ℤ), ∃ N : ℕ, ∀ i : ℕ, N ≤ i → fam (m - (i : ℤ)) w = 0

— which is exactly FLM (8.5.6)'s local finiteness and is **base-agnostic**; the nonnegativity demand
lives in the separate constructor `ofNonnegative` (`:151`), which is the cut-off artefact.  So **the
interface needs no change**: the alignment is a change of *which family* is fed to it, not of the
interface.  This removes the largest feared item from the migration.

**The verdict, and its numbers.**  A **seam change with a wide but shallow tail**, not a layer rebuild:
2 declaration edits (`MM.FLM85Cp.heisFam`, `MMFLM810F.modelBase`) + ~20--25 files touched, of which only
~5 need genuinely new proofs — because **both honest replacements already exist**
(`MM.FLM85ZM.heisFamZero`, `MM.FLM810TB.baseRepaired`).  Occurrence counts (word-boundary `grep -c` over
`Definitions/` plus `FinalCheck.lean`): `heisFam` 183 hits in 22 files but only **7 statement sites**;
`modeVL` 943/85 but ~8 statement sites; `modelBase` 153/26; `YCoeff` 193/34; `TruncatedField` 272/42
**with 0 edits needed**; `YFam` 253/17; `Yzero` 213/23; `heisFamZero` 195/23.

**The insulation that makes the tail shallow.**  `splitMinus_heisFamZero_eq`
(`Definitions/MMFLM85ZeroModeField.lean:219`) and `opOpenBox_heisFamZero_eq` (`:233`) say the corrected
and defective fields have the *same* creation half and the *same* open-box product; so everything routed
through `splitMinus`/`opOpenBox` needs **no re-proof**.  The genuinely `splitPlus`-side breakages are
seven, and every one has a landed counterpart:
`MM.FLM85Ap.splitPlus_heisFam_apply` (`MMFLM85Action.lean:290`, false at `m = −1`) and
`splitPlus_heisFam_neg` (`:296`, false at `k = 0`) against
`MM.FLM85ZM.splitPlus_heisFamZero_apply`/`_neg_one`/`_neg`
(`Definitions/MMFLM85ZeroModeField.lean:162`/`:150`/`:175`);
`MM.FLM87FC.tailSummand_eq_normalOrderedHeisPair` (`MMFLM87SugawaraFoldClose.lean:136`, false at
`k' = 0`) and `actionFold_eq_normalOrderedHeisFinsum` (`:169`) against
`MM.FLM87ZN.tailSummandZero_eq` (`Definitions/MMFLM87ZeroModeNormalOrder.lean:197`) and
`actionFoldZero_eq_normalOrderedHeisFinsumZero` (`:236`);
`MM.FLM845CN.annihPair_oscField_neg_one_eq_zero` (`MMFLM845ContractionNeg.lean:165`, a theorem *about*
the defect); and `MM.FLM85Ap.modeVL_zero` (`MMFLM85ActionRelations.lean:87`, only if `modeVL` is itself
repaired — see below).

**The riskiest single step, named.**  The `modelBase → baseRepaired` substitution
(`Definitions/MMFLM810Fields.lean:311`).  `modelBase` **ignores the central extension `E`** — `YCoeff`
never uses it — whereas `baseRepaired` genuinely uses `E` through `actVL` inside `midFam`.  So every
`modelBase`-statement re-elaborates with `E` as a real parameter, and every `Hrel`/`Prescription`
hypothesis stated *at* `modelBase` (`MMFLM810Fields.lean:477`/`:565`, `MMFLM810ActionFields.lean:123`,
`MMFLM85IterateStep.lean:421`--`:492`, `MMFLM84VacuumField.lean:330`/`:422`, `MMFLM810Creation.lean:122`,
`MMFLM810Truncation.lean:80`) becomes a hypothesis about a **provably different family**
(`MM.FLM810TB.baseRepaired_ne_modelBase`, `Definitions/MMFLM810TranslationBase.lean:250`) and must be
re-proved.  D0's recommendation, which the dispatcher adopts: **do the `heisFam`-side rewiring as one
self-contained batch, and leave the `modelBase → baseRepaired` substitution to a separate one.**

**One recommendation the dispatcher declines, with the reason.**  D0 suggests **not** repairing
`modeVL` itself (`modeVL a 0 = 0`), because that would falsify `MMFLM85ActionRelations.lean:87` and
re-elaborate all 34 `YCoeff` files "for no gain".  That is right about the cost but wrong about the goal:
FLM (7.1.41) gives `a(0)` its own action `hZeroVL` **on the lattice factor**, and `modeVL a n` is defined
as the Fock mode tensored with the identity, so `modeVL` is the right object **away from `n = 0`** and the
zero mode is the separate operator `hZeroVL`.  The alignment therefore does not need `modeVL` repaired —
it needs the **field** `a(z)` to carry both pieces, which is exactly what `heisFamZero` does (it is
`hZeroVL` at `m = −1` and `modeVL a (−m−1)` elsewhere).  `modeVL_zero` stays a true theorem about
`modeVL`, and no `YCoeff` file is re-elaborated.  Recorded because the distinction between the *mode
family* and the *field* is what the whole alignment turns on.

**D2 dispatched on the strength of this report** (`Definitions/MMFLM85CanonicalField.lean`, namespace
`MM.FLM85CF`, additive only): make the corrected (8.4.7) field canonical, land the agreement/difference
ledger (including the `k = 0` case where the landed `splitPlus_heisFam_neg` is false, side by side with
its landed counterpart), restate the insulation facts that make the tail shallow, and mark the defective
declarations deprecated — from the new file, without editing any existing one.

**D1 ACCEPTED — `Definitions/MMFLM85BaseFieldAligned.lean`** (331 lines, namespace `MM.FLM85BA`, 5
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  Alignment step 1 is done, and it settles the
truncation question that batches 156 and 157 argued about — **both sides were partly right.**

**Landed.**  `genFam E a m := YFam E a (−m−1)`, with `genFam_eq_reflectFam` (definitional bridge to the
landed `MM.FLM84TV.reflectFam`), `genFam_iotaVL : genFam E a m (ι c) = latticeState E a c ⟨a,c⟩ m`,
`genFam_zero_label` (at `a = 0`: `1` at `m = −1`, `0` elsewhere), and `genFam_vacuumVL_eq_modelBase`
(the vacuum sector, where the defective base agrees).  `baseAligned E : L → TruncatedField F L` with
`fam = genFam E a`, its truncation taken **per vector** from `MM.FLM84LF.YFam_eq_zero_of_gt`,
`baseAligned_zero` (8.5.3, from the full `YFam_zero_label` — **not** from `modelBase_zero`, which is
vacuum-only), and — importantly — `baseAligned_fam_eq_baseRepaired`, which is **`rfl`**: the object this
batch built is **definitionally the `baseRepaired` of batch 156**.  Finally `Yaligned := Yzero (baseAligned E)`
with `Yaligned_iotaVL : Yaligned E (ι a) = genFam E a` (all three bridges `rfl`, landed as
`stateOfVL_base_state`, `actionPrescriptionTAZero_base_state`).

**The truncation question, resolved by the source.**  The statement this batch's predecessor tried and
the dispatcher twice mis-stated — `∀ m < 0, genFam E a m = 0`, equivalently `∀ k ≥ 0, YFam E a k = 0` —
is **false as an operator identity**, and is now refuted **unconditionally**
(`genFam_lower_truncation_false_rankOne`, at rank one: `genFam E 1 (−1) ι(−1) = ε•ι(0) ≠ 0`, the zero
mode).  What is true, and is now a theorem, is FLM (8.5.8) read correctly — **at the state `ι(1)`**:

    genFam_vacuum_creates : genFam E a 0 (vacuumVL) = iotaVL a        (the limit of (8.5.8))
    genFam_lower_truncation_vacuum : ∀ m < 0, genFam E a m (vacuumVL) = 0

and, at a general lattice state, the **sharp threshold**

    genFam_lower_truncation_iotaVL : ∀ m < ⟨a,c⟩, genFam E a m (ι c) = 0

with the threshold attained (`genFam_iotaVL_pairing_eq`: `ε(a,c)·ι(a+c)`), plus the per-vector
`∃K` form `genFam_eq_zero_of_lt` — FLM (8.10.5) at the base.  So the honest field's lower bound is
**`⟨a,c⟩`, not `0`**, which is exactly the `z^{−(a,a)/2}` of (8.4.17); the dispatcher's hand computation
of batch 156 got the composition order wrong, and its "refutation" of the *base* was therefore wrong,
while its instinct that "an operator-level statement fails" was right for the *operator* form only.
Both halves are now in the record, and the sharp threshold is the aligned statement.

**The brief's central claim was false a third time** (item 2 conflated the operator identity with the
state-level (8.5.8)), its `ofNonnegative` route was impossible (that constructor's hypothesis *is* the
refuted statement), and its (8.5.3) citation was insufficient (vacuum-only).  It also missed that
`genFam`/`baseAligned` already existed as the landed `baseRepaired`.  The `omega` trap did **not** fire:
the file contains no live `omega`/`linarith` — the two dangerous `ℤ` steps are hand-built
(`Int.add_lt_add_right`, `neg_lt_neg_iff`, `sub_lt_zero`, `exists_nat_gt`) exactly as `AGENTS.md` now
prescribes, and that is the first payoff from that recorded measurement.

**Consequence for the migration.**  The base substitute is now **landed twice over** (`baseRepaired`,
`baseAligned`, definitionally equal) and carries (8.5.3), the correct truncation, and the inhabitance of
the restated generator hypothesis.  What remains of the alignment is: (i) the `heisFam`-side rewiring of
the seven `splitPlus`-stated breakages (self-contained, counterparts landed); (ii) the
`modelBase → baseAligned` substitution at the ~8 hypothesis sites, with `E` becoming a real parameter —
the risky step, to be done as its own batch; and (iii) `Definitions/MMFLM85CanonicalField.lean` (task D2,
in flight) which marks the defective declarations and lands the agreement/difference ledger.

**X1 ACCEPTED — `Definitions/MMFLM84DerivYFam.lean`** (341 lines, namespace `MM.FLM84DY`, 5 guards;
verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  **This batch is the strongest empirical vindication
of the owner's alignment directive so far**, because the task turned out to require the corrected field
for its statement even to be *true*.

**Landed, with no hypotheses.**  At every power and every lattice generator:

    actionFold_iotaVL : (FLM85TA.actionFold [heisFactor a] (baseRepaired E a)).fam m (ι c)
                     = deriv (baseRepaired E a).fam m (ι c)

— the honest (8.4.23) at `YFam` on the (8.5.4)/(8.5.11) generators — together with its two halves
`headOp_baseRepaired_iotaVL`, `tailOp_baseRepaired_iotaVL`, the (8.4.1) ODE
`deriv_creationExpVL : deriv (creationExpVL a) = flatMul (splitMinus (heisFam a)) (creationExpVL a)`
(new), and `baseRepaired_fam_iotaVL`.  **Residual**, named exactly: the general state `w = x ⊗ ι(c)`,
`x ≠ 1`, needs the (8.4.16) Leibniz rule for the truncated one-factor action; its head half is landed
(`MM.FLM810WR.headOp_deriv`), its **tail half is not** (`MMFLM810HeadLeibniz`'s header records it
missing).  The agent also flagged, correctly, that that header's weight count is a *hypothesis* rather
than a theorem — after reindexing the tail weights do add up — so the tail Leibniz is likely provable.

**THE CORRECTION, and it is the alignment's own argument stated by a proof.**  The brief's literal target
`deriv (YFam E a) = opOpenBox (heisFam …) (YFam E a)` is **false**, for two independent reasons:

1. **index convention**: `deriv` is power-indexed (`m ↦ (m+1)·s_{m+1}`) while `YFam` is (8.5.15)-indexed
   (`YFam E a m` is the coefficient of `z^{−m−1}`), so `deriv (YFam E a)` is not the derivative of the
   field at all; the `baseRepaired`/`reflectFam` carrier is the correct one;
2. **the zero mode is load-bearing**: the identity needs the factor's family to be `heisFamZero`
   (`MM.FLM85ZM`), whose `z^{−1}` coefficient is `hZeroVL` — the (8.4.14) zero mode — because that term
   is exactly what cancels the head at `p = −1` on `ι(c)` with `⟨a,c⟩ = −1`.  **With the landed
   `heisFam a` (zero mode deleted, `modeVL a 0 = 0`) the identity is FALSE** there: head `≠ 0`,
   tail `= 0`, `deriv = 0`.  The relevant landed (8.4.23) is therefore
   `MM.FLM85ZM.deriv_YCoeff_eq_opOpenBox_heisFamZero` (`Definitions/MMFLM85ZeroModeField.lean:242`),
   **not** `MM.FLM84DI.deriv_YCoeff_eq_opOpenBox_heisFam` (`Definitions/MMFLM84DerivId.lean:146`).

*This is the owner's point, proved: a formaliser following the old definitions would have landed a false
theorem and then spent batches "proving" things about it.  The alignment is not cosmetic.*

**Two smaller corrections, both recorded in place.**  W1's docstring
(`Definitions/MMFLM810TranslationBase.lean:48--50`) mis-states the cancellation — the tail is `−head`,
not equal to it, and the identity at `p = −1` reads `0 = 0` rather than cancelling two terms of size
`2×`; and the page-offset note in this ledger is off by one for a zero-indexed reader
(`r.pages[246]` is printed 192; `pdftoppm -f 247` is needed).  The `AGENTS.md` `le_or_lt`-absent trap
fired once and cost one build round — `by_cases` plus `not_le.mp` is the fix, as recorded there.

**D2 ACCEPTED — `Definitions/MMFLM85CanonicalField.lean`** (299 lines, namespace `MM.FLM85CF`, 7
guards; purely additive; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`,
token check at zero, `FinalCheck.lean` acceptance build `--- OK ---`).  Alignment step 2 is done: the
corrected (8.4.7) field now has a **name that says what it is**, the defective one has a migration
pointer, and the defect itself is a **theorem**.

**Landed.**  `canonicalField a := MM.FLM85ZM.heisFamZero a` (an `abbrev` whose body *cites* the landed
field rather than restating it, docstring quoting (8.4.7)); the agreement/difference ledger
`canonicalField_apply_of_ne` (agrees with `heisFam` for `m ≠ −1`), `canonicalField_neg_one`
(`= hZeroVL (ofLattice a)`), `canonicalField_eq_heisFam_of_ne`,
`canonicalField_ne_heisFam_neg_one`; the insulation facts restated
(`splitMinus_canonicalField_eq`, `opOpenBox_canonicalField_eq`, and the general
`opOpenBox_congr_of_splitMinus_eq`) with (8.4.23) verbatim as
`deriv_YCoeff_eq_opOpenBox_canonicalField`; and the defect as a proposition,
`splitPlus_defect_at_zero : splitPlus (canonicalField a) (−1) = hZeroVL (ofLattice a) ∧
splitPlus (heisFam a) (−1) = 0`, with `splitPlus_canonicalField_neg_of_pos` showing the landed
`splitPlus_heisFam_neg` is true for exactly `k ≥ 1`, and `splitPlus_defect_witness` exhibiting a label
where the defective value kills `ι(b)` and the canonical value is the eigenvalue times `ι(b)`.

**A measurement that closes a door, recorded in `AGENTS.md`.**  The `deprecated` attribute **cannot**
be applied to a declaration in another module in this pin: both
`attribute [deprecated (since := "…")] MM.FLM85Cp.heisFam` and the two-name form fail with *"Cannot add
attribute '[deprecated]' to declaration '…' because it is in an imported module"*
(`Lean/Attributes.lean`, `ParametricAttribute.add` rejects `(env.getModuleIdxFor? decl).isSome`).  So
`heisFam`, `modelBase` and `YCoeff` **cannot be made to warn on use** from a new file; the available
routes are an edit to their own files or the `## Migration` block plus `#check`-level pointer lemmas
that D2 landed (`canonicalField_pointer`, `baseRepaired_pointer`, `YFam_pointer`, `YCoeff_pointer`).
This is why the alignment's remaining work must be done by **rewiring statements**, not by making the
old names complain.

**A brief error that had to be caught by the compiler.**  The brief (and D0's prose) invited the
generalisation that the two fields' halves coincide as families.  That is true for `splitMinus` and
`opOpenBox` — and **false for `splitPlus`**: at `m = −1` the corrected value is `hZeroVL (ofLattice a)`
and the defective value is `0`, so `splitPlus (canonicalField a) ≠ splitPlus (heisFam a)`.  The agent
landed the false family equality, saw it fail, and replaced it with the correct `k ≥ 1` statement —
which is exactly the behaviour `AGENTS.md` asks for.  Also corrected: `MMFLM87SugawaraFoldClose.lean`'s
statement sites are `:134` and `:167` (D0's `:136`/`:169` are proof lines), and the zero-mode witness
needs a label `b` with `⟨ā,b̄⟩ ≠ 0` to be nonvanishing.

**A guard-measurement correction.**  Batch 156 recorded "a 126-character guard message prints on one
line, so the wrap threshold is above 120".  This batch's guard for
`deriv_YCoeff_eq_opOpenBox_canonicalField` is **121** characters and **wrapped**.  So the wrapping is not
a function of length alone; `AGENTS.md` now says the only safe route is empirical — add the guard with a
one-line expectation, build, and read the diff that `guard_msgs` prints.

**Z1 ACCEPTED — `Definitions/MMFLM85SplitPlusAligned.lean`** (375 lines, namespace `MM.FLM85SP`, 17
declarations, 5 guards; purely additive; verified by the dispatcher: rebuild from a deleted `.olean`
`--- OK ---`, token check at zero, `FinalCheck.lean` acceptance build `--- OK ---`).  Alignment step 3:
**every defective `^+`-side statement now has its corrected counterpart, in one place, with the defect
itself as a proposition.**

**Landed.**  For the two `splitPlus` statements: `splitPlus_canonicalField_apply` (cited from
`MM.FLM85ZM`), the `m = −1` correction `splitPlus_heisFam_apply_defect_at_neg_one` (defective instance
`= modeVL a 0`, corrected `= hZeroVL (ofLattice a)`, and `modeVL a 0 = 0`), the `k ≥ 1` and `k = 0`
halves `splitPlus_canonicalField_neg`/`_neg_one`, the validity range
`splitPlus_canonicalField_eq_heisFam_of_pos`, the `k = 0` correction
`splitPlus_heisFam_neg_defect_at_zero`, and `canonicalField_neg_one_ne_defective_zero` (the two
operators genuinely differ whenever `⟨a,b⟩ ≠ 0`).  For the Sugawara pair:
`tailSummandZero_eq_canonicalField` and `actionFoldZero_eq_normalOrderedHeisFinsumZero_canonicalField`
(cited from `MM.FLM87ZN`), with `tailSummand_defect_at_zero`.  For the contraction: **a counterpart that
did not exist before** — `annihPair_canonicalField_latticeField`, the **unguarded** (8.4.19)/(8.4.25)
form at every `m < 0` (built from the landed `MM.FLM84CT.hZeroVL_contraction` at `m = −1` together with
`annihPair_oscField_latticeField` at `m < −1`), plus `annihPair_canonicalField_neg_one`,
`heisFam_eq_oscField` (`rfl`) and `annihPair_heisFam_unguarded_false` (cited from `MM.FLM84CN`).  And for
the Leibniz head half: `headOp_deriv_canonicalField`, which needed no correction — `headOp_deriv` is
quantified over arbitrary families and holds verbatim at the corrected field.

**The consumption table, which is what a rewiring batch needs** (live mentions, comment-stripped, over
`Definitions/` plus `FinalCheck.lean`; **every consumer uses the defective name in a proof only — none
states it**): item 1 → 3 consumers in 2 files; item 2 → **7 consumers in 4 files**; item 3 → 1, no
external consumer; item 4 → 2, with `MM.FLM87ZD.sugawaraMode_apply_eq_sum_pair` the only out-of-file one
guarded in `FinalCheck.lean:5641`; item 5 → 4, none external; item 6 (`modeVL_zero`, **not** defective) →
11 files / 26 sites with two homonyms; item 7 → 1.  **Riskiest single rewire: item 2**, because
`KillsAbove`/`Factor.nil` is built on `splitPlus X (−k−1)` at *every* `k`, so the true hypothesis `0 < k`
breaks `exists_killsAbove_heisFam`, `…heisFamZero` and both fold lemmas.  Suggested order:
3 → 4 → 1 → 5 → 2.

**Brief errors of record** (all `grep`-verified by the agent): the namespaces are `MM.FLM85Ac` for items
1--2 (not `Ap`) and `MM.FLM85AR` for item 6; item 5's file is `Definitions/MMFLM84ContractionNeg.lean`
(there is no `MMFLM845ContractionNeg.lean`), its statement is at `:163`, namespace `MM.FLM84CN`, and its
counterpart is **not** `annihPair`-named but `MM.FLM84CT.hZeroVL_contraction`
(`Definitions/MMFLM84Contraction.lean:659`); item 7 is **not** defective, so the brief's title calling all
seven defective was wrong; the brief's seven are **not** B157 §3a's seven —
`MM.FLM85LL.heisFam_add` (`Definitions/MMFLM85LabelLinearity.lean:244`, one consumer
`factorFamily_add:257`, corrected twin `MM.FLM85ZP.heisFamZero_add`,
`Definitions/MMFLM85ZeroPrescription.lean:118`) was dropped; and B157's second `modeVL_zero` homonym is
`MM.FLM810ZMT` (`Definitions/MMFLM810ZeroModeTwoFactor.lean:100`), not `MM.FLM810ZM`.  The
`MMFLM85LabelLinearity`/`heisFam_add` item is added to the rewiring list by this entry.

**Guard measurement, third data point.**  A 118-character message printed on one line; a 121-character
message wrapped.  Combined with batch 156's 126-on-one-line, this confirms `AGENTS.md`'s revised rule:
the threshold is not a function of the message length alone, so the route is empirical — add the guard
with a one-line expectation, build, and read the diff.  The dispatcher has now hit this three times and
each cost exactly one build round.

**Y1 ACCEPTED (as a reduction) — `Definitions/MMFLM84LeibnizTail.lean`** (241 lines, namespace
`MM.FLM84LT`, 4 guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`,
token check at zero; to be wired into `FinalCheck.lean` in the next batch together with its siblings).
The tail half of (8.4.16) is **not** a theorem yet — but its exact shape is now **known**, and that is
the batch's result.

**The true shape of the tail Leibniz rule** (the agent's derivation, which the dispatcher checked):

    deriv (tailOp X Y) m = headOp X.fam (deriv Y) m + tailOp (dFactor X) Y m

The mechanism: `tailWindow X Y m M = Σ_{k≤M} Y (m+k+1) (X⁺_{−k−1} w)`, and `deriv s m = (m+1) • s (m+1)`
puts the extra weight *inside* `Y`; with `j = k+1` the sum becomes `Σ_{j≥1} (m+j+1) • Y (m+j+1) (X⁺_{−j} w)`
and, for `j ≥ 1`, `X⁺_{−j} = splitPlus (dFactor X).fam (−j)` (from the landed
`MM.FLM84.deriv_splitPlus`, `Definitions/MMFLM84NormalOrder.lean:235`).  So **the two halves trade the
outer index `k = 0`**: the `k = 0` summand becomes the *head* term, and the rest is the *tail at the
shifted factor*.  The **naive** form `tailOp (dFactor X) Y m + tailOp X (deriv Y) m` is **false** — it is
off by exactly the creation half, which is landed as the conditional
`MM.FLM84LT.tailOp_deriv_sub`.  The brief's guessed product rule
`tailOp m (x ⊗ ιc) = (tailOp m x) ⊗ ιc + …` **does not exist** in the definitions.

**Landed**: `tailLeibnizResidual` (the `Prop` above, with its derivation in the module docstring),
`tailOp_deriv_sub` (the conditional difference identity), `derivActionFamilyResidual`,
`actionFamily_modeVL` and `generalStateDeriv` (the two inputs of the general-state (8.4.23), as named
`Prop`s), `generalStateDeriv_iotaVL` (**its generator case IS batch 157's
`MM.FLM84DY.actionFold_iotaVL`, verbatim** — so the (8.4.23) at general states is now one named
`Prop` away), plus `negOne_smul` and `modeVL_vacuumVL_eq_zero`.

**A false intermediate, measured and recorded so that no future batch repeats it**: "the corrected field
vanishes at index `m+1` for `m ≤ −2`" is **FALSE** — at `m = −2` the index `m+1 = −1` is the (7.1.33)
zero-mode index, where `heisFamZero a (−1) = hZeroVL (ofLattice a) ≠ 0`, and for `m ≤ −3` it is the
annihilation mode, which kills the vacuum but is **not** the zero operator ((7.1.5)/(7.1.32) are
*vector-level* statements).  Any proof of the tail rule must do the reindexing **pointwise on the
vector**, which is exactly where the mechanisation budget was lost.

**A dispatcher measurement, offered to the next attempt.**  The residual is a finite reindexing of
`Finset.range`, and the dispatcher verified the *mathematics* of the reindexing by hand at
`tailWindow`'s definition (`Definitions/MMFLM85Action.lean:400`):

    deriv (tailWindow X.fam Y m M) w
      = Σ_{k≤M} (m+k+2) • Y (m+k+2) (X⁺_{−k−1} w)
      = (m+1) • Y (m+1) (X⁺_{−1} w) + Σ_{k≤M−1} (m+k+3) • Y (m+k+3) (X⁺_{−k−2} w)

whose two pieces are `headOp X.fam (deriv Y) m` at `i = 0` and the tail at the shifted index — so the
residual **is** provable, and the work is `Finset.sum_range_succ'` plus `Int`-cast normalization.  The
dispatcher's own throwaway probe reached the final arithmetic goal and no further; it is recorded here
rather than left as a claim, and the file was deleted.

**B1 ACCEPTED — `Definitions/MMFLM810TheoremAligned.lean`** (299 lines, namespace `MM.FLM810TA2`, 4
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  **Theorem 8.10.2 is now stated at the book's field**,
and one of its four inputs is discharged outright.

**The landed boundary** (verbatim type):

    theorem8102_of_generatorFieldsAligned : ... →
      JacobiOnStateTargets bL form (vertexOpOfField (Yaligned bL form E)) →
      L0OnWeightGenerators form (vertexOpOfField (Yaligned bL form E)) om →
      TranslationOnStateData bL form (vertexOpOfField (Yaligned bL form E)) om →
      VirasoroOnStateData bL form (vertexOpOfField (Yaligned bL form E)) om r →
      Theorem8102 form r

with `theorem8102_of_generatorFieldsAligned_l0` the same at `om := conformalVector bL form hnd` and
**no `L0` hypothesis**.  Also landed in the same file: (8.10.5)--(8.10.7) at `baseAligned`
(`componentTruncationAligned`, `vacuumOperatorAligned`, `creationRegularAligned`,
`creationPropertyAligned`) and the `VacuumNormalized` spelling of (8.10.6).

**The four inputs, measured:**

| input | status |
| --- | --- |
| `hL0` (8.10.12) | **DISCHARGED OUTRIGHT** — `l0OnWeightGenerators_aligned`, from the *base-generic* `MM.FLM810ZMW.L0OnWeightGenerators_zero` plus `MM.FLM85BA.baseAligned_zero`; the `L0` field needs only `hnd` and symmetry of `form`; |
| `hvir` (8.10.9) | **REDUCED** to the named `Prop` `MM.FLM87SA.FreeBosonSugawaraBracketZero` (FLM (8.7.9)) by the landed `MM.FLM87SA.virasoroOnStateData_of_freeBosonBracketZero`; |
| `htrans` (8.10.13) | **OPEN** — the landed links are the base-state iff `MM.FLM810TB.translationOnStateData_baseRepaired_base_state_iff` (at `D = ⟨[], a⟩`, equivalent to the honest (8.4.23)) and `MM.FLM84DY.actionFold_iotaVL` (at the lattice generators); |
| `hjac` (8.10.8) | **OPEN** — `JacobiOnStateTargets` has no producer for any field in the repository; |

plus the four inherited hypotheses `hpd`, `hrank`, `hW`, `hfin` of `MM.FLM810.theorem8102_of_fields`.
**Theorem 8.10.2 is not unconditional**, and the file says so.

**Where the brief was wrong, and two of these were the dispatcher's own errors:**

1. **The dispatcher claimed the corrected assembly line takes the base as a parameter.  It does not**:
   `MM.FLM810CZA.theorem8102_of_generatorFieldsZero` fixes every hypothesis at
   `Yzero (modelBaseField E weight)` (`Definitions/MMFLM810CorrectedZeroAssembly.lean:228`--`:244`), so
   the boundary had to be **re-proved** at `Yaligned`, not instantiated.  This is the sixth brief in the
   campaign whose key step was asserted without compiling it.
2. **The dispatcher's `L0` route was needlessly indirect** (and omitted that the field needs `hnd` and
   form symmetry): `L0OnWeightGenerators_zero` is base-generic, so `baseAligned_zero` alone suffices and
   no transport from `baseRepaired` is needed.
3. **The dispatcher overstated translation**: `MMFLM84LeibnizTail.lean` lands its residuals as
   **unproved** `def … : Prop`s and states that nothing there decides `TranslationOnStateData`; there is
   **no** landed reduction of the predicate to a residual — only the base-state iff and the
   lattice-generator case.  (This entry corrects batch 158's own Y1 paragraph accordingly: the tail
   Leibniz rule's *shape* is known and the residual is provably a finite reindexing, but **no reduction
   of `TranslationOnStateData` to it is landed**.)
4. **The dispatcher named the wrong Virasoro route**: `MM.FLM87ZBC.virasoroOnStateData_of_named` needs
   two further named statements that that file's own §4b measures untenable; the direct
   `MM.FLM87SA.virasoroOnStateData_of_freeBosonBracketZero` (bracket only, base as a parameter) is the
   route that works.

**T1 ACCEPTED — `Definitions/MMFLM84TailLeibnizProof.lean`** (280 lines, namespace `MM.FLM84TLP`, 9
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  **The (8.4.16) Leibniz rule is now unconditional —
and batch 158's residual was false.**

**The true rule** (a plain product rule, with the tails pairing as `k ↦ k+1`, **not** `k ↦ k`):

    tailLeibniz_tailOp : deriv (tailOp X Y) m = tailOp (dFactor X) Y m + tailOp X (deriv Y) m
    actionFamily_deriv : deriv (FLM85Ac.actionFamily X Y) m
                       = FLM85Ac.actionFamily (dFactor X) Y m + FLM85Ac.actionFamily X (deriv Y) m

the second being the **full (8.4.16) Leibniz rule, unconditional**, with head half = the landed
`MM.FLM810WR.headOp_deriv_factor` and tail half = the new `tailLeibniz_tailOp`.  Cores:
`tailWindow_deriv_window` and `tailOp_deriv_pointwise`.

**Batch 158's `MM.FLM84LT.tailLeibnizResidual` is REFUTED**, unconditionally
(`not_tailLeibnizResidual`): the residual asserted `deriv (tailOp X Y) m = headOp X.fam (deriv Y) m +
tailOp (dFactor X) Y m`, and `tailLeibnizResidual_iff` shows that is **equivalent to**
`tailOp X (deriv Y) m = headOp X.fam (deriv Y) m` for all `X, Y, m` — i.e. to the annihilation and
creation halves of `8X(dY)8` coinciding, which is false.  The counterexample is the corrected factor
`heisFactor (bL i)`, the lower-truncated family `testFamily` (identity at power 1, zero elsewhere),
`m = 0` and the vacuum: `tailOp_vacuumVL` gives `0` while `headOp X.fam (deriv testFamily) 0 =
splitMinus X.fam 0 = modeVL (bL i) (−1)`, which creates a nonzero state.  **So the dispatcher's
"verification by hand", offered to T1 as the plan, was wrong at exactly the step it flagged as
"plumbing": splitting off the `k = 0` summand does not produce `headOp`; it trades `tailOp X (deriv Y)`
for `headOp X.fam (deriv Y)`, and those are different sums.**  The correct shift is `k ↦ k+1`, and with
it the two tails' weights sum to `m+1`.

**Consequences, recorded so that nothing downstream uses the false premise.**
`MM.FLM84LT.tailLeibnizResidual`, and everything conditional on it — `MM.FLM84LT.tailOp_deriv_sub`,
`MM.FLM84LT.derivActionFamilyResidual`, and `MM.FLM84LT`'s §"what this file does not prove" framing —
**rest on a false premise** and must not be used; the replacements are `MM.FLM84TLP.tailLeibniz_tailOp`
and `MM.FLM84TLP.actionFamily_deriv`.  `MM.FLM84LT.derivActionFamilyResidual` additionally names the
**uncorrected** fold (`FLM85Ac.actionFamily`) where the corrected head over a `TruncatedField`
(`FLM85TA.actionFamily`) is needed, so the (8.10.13) reduction must be restated for the corrected fold —
that is the next task on the translation front, and it is now a **restatement over proved halves**
rather than a proof search.

**The lesson, and it is the third of its kind in two batches.**  A disjoint-propagation of the same
residual has now been asserted false by two different agents (`MM.FLM810HeadLeibniz`'s header and
`MM.FLM84LT`'s), corrected once by a third, and the dispatcher itself endorsed the false form.  The rule
that caught it is the one in `AGENTS.md`: **a claimed route is a hypothesis until compiled** — the
dispatcher's hand derivation, however detailed, was still a hypothesis, and T1 was right to compile it
rather than build on it.

**T2 ACCEPTED — `Definitions/MMFLM810TranslationGeneral.lean`** (524 lines, namespace `MM.FLM810TG`, 8
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  The translation field of Theorem 8.10.2 is now fully
**reduced**, and the reduction identified the input that is genuinely missing — it is not the Leibniz
rule.

**Target 1 — LANDED: the corrected-fold Leibniz rule, and the object it needed.**  The second argument
of `MM.FLM85TA.actionFamily` is a `TruncatedField`, so `deriv Y` cannot be passed: the missing object is
the **derivative field**, and no truncation hypothesis is needed (`deriv` preserves lower truncation,
bound `+1`):

    noncomputable def dField (Y : TruncatedField F L) : TruncatedField F L := ⟨deriv Y.fam, …⟩
    headOp_deriv_field      : deriv (FLM85TA.headOp X.fam Y) m
                            = FLM85TA.headOp (dFactor X).fam Y m + FLM85TA.headOp X.fam (dField Y) m
    actionFamily_deriv_field : deriv (FLM85TA.actionFamily X Y) m
                            = FLM85TA.actionFamily (dFactor X) Y m + FLM85TA.actionFamily X (dField Y) m
    actionFold_deriv_field   : the one-factor fold version
    actionFold_deriv_dFold   : ∀ l Z m, deriv ((FLM85TA.actionFold l Z).fam) m = (dFold l Z).fam m

**Target 2 — the honest reduction, and the real input.**  `MM.FLM84LT.generalStateDeriv` is **not**
reachable from `actionFold_iotaVL` plus a creation-list induction: **`{ι(c)}` does not span `V_L`**, and
the induction additionally needs a fact about the Heisenberg modes at an arbitrary vector.  Landed
instead:

    baseStateTranslation_iff_generalStateDeriv :
      (∀ E, BaseStateTranslation bL form hnd E) ↔ MM.FLM84LT.generalStateDeriv bL form
    translationOnStateData_iff_dFold :
      ⟨the (8.10.13) component at D, m⟩
        ↔ Yzero base (L(−1) v_D) (−m−1) = (dFold (datumFactorsZero D) (baseRepaired E D.a)).fam (−m−1)
    def LMinusOneCreationMode (hnd) (E) : Prop        -- the named state half
    lMinusOneCreationMode_iota                          -- its hypothesis-free instance at ι(c)

So **no state of `TranslationOnStateData` is newly decided**: the base states are *equivalent* to the
open `generalStateDeriv`, and the oscillator states are equivalent to the state half
`[L(−1), α_b(−n)] = n·α_b(−n−1)` at an arbitrary vector — landed only at `ι(c)`
(`MM.FLM810TRD.LOf_conformalVectorZero_neg_one_modeVL`).  The file says this plainly.

**Where the brief was wrong, and one of these is a trap now in `AGENTS.md`.**  (i)
`MM.FLM810WR.headOp_deriv_factor` is the **flat** head (`FLM85Ac.headOp`, window `m`), **not** the
corrected head (`FLM85TA.headOp`, window `Y.bound w m`) — so "both halves are already proved" was
false for the corrected fold, and a new head half was required.  (ii) The creation-list-induction route
is unavailable for the reason above.  (iii) Three new API traps were measured and are recorded:
`Finset.sum_apply` does not fire on `(∑ f) w` for `LinearMap`s (use `LinearMap.sum_apply`);
`Module.End`'s `LinearMap.instSMul` defeats `Int.cast_smul_eq_zsmul` (prove scalar identities at the
vector level); and `rw` cannot apply an operator-level lemma under `c • (f w)` (use a vector-level
lemma or `congrArg (· w)`).

**Where this leaves Theorem 8.10.2**: `hL0` discharged; `htrans` reduced to the state half
`LMinusOneCreationMode` (plus the now-proved Leibniz rule); `hvir` reduced to FLM (8.7.9); `hjac` open.

**U1 (batch 160) FAILED — no report, and the cause is a scheduling error by the dispatcher, not the
mathematics.**  The task was to prove the state half `MM.FLM810TG.LMinusOneCreationMode` — the last
input of the translation field — by reducing it to the Fock factor.  The agent died mid-proof, leaving a
single partial lemma (`actionFold_two_neg_one_modeVL_apply`, 249 lines, no guards); the file built, but
it proves none of the target.  Its file was **deleted** so that a re-dispatch does not collide with a
stale revision, and the partial result is recorded here rather than kept: it is an intermediate step of
a proof that has to be redone as a whole.

**The scheduling error.**  Batches 159 and 160 were dispatched back to back at a point where the session
had been running long; the dispatcher did not confirm that the previous batch's reports had been read
and recorded before opening the next, and `AGENTS.md`'s own dispatching rule says **one batch at a time**
unless the files are disjoint.  A subagent that dies without a report leaves the tree in an unknown
state, which is exactly what happened: the file had to be inspected, built, judged incomplete (one
lemma, no guards, not the target) and removed.  The rule that follows is cheap and is now the practice:
**before dispatching a batch, check `git status` and the previous batch's reports; never open a new
batch on top of an unfinished one.**

**The mathematics is unaffected**: the state half is still the last input of `htrans`, the plan
(Fock-factor reduction, since `modeVL` is the Fock mode tensored with the identity) still stands, and
the task is re-dispatched with a tighter scope.

**U2 ACCEPTED — `Definitions/MMFLM87SugawaraStateHalf.lean`** (299 lines, namespace `MM.FLM87SH`, 6
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).

**The Fock-level state half was already landed, and in a place no brief had named.**
`MM.Heisenberg.L_commutator_alpha` (`Definitions/MMFockVirasoro.lean:649`) and its `m = −1` instance
`L_neg_one_commutator_alpha` (`:1572`) give `[L(−1), α(−k)] = k·α(−k−1)` on the Heisenberg Fock space —
**and the brief's suggested homes (`MM.FLM87FZ`/`SA`/`ZB`) do not carry it**; `MM.FLM87FZ` in fact
records that its operator-level `finsum` is `0`.  This is the third time a task has found its target
already landed under a different name, which is worth a rule: **before proving an identity, grep the
whole `Definitions/` for its statement shape, not just the files whose names suggest it.**

**Landed new.**  On the repository's own Fock carrier `M1 F L` (the transport is forced: the
repository's Sugawara is built from the (8.4.16) folds and acts on `V_L`, not on `M1`, so the only
`L(−1)` on `M1` is the transported `MM.FLM87ST.fockSugawara`):

* `fockSugawara_comm_mode` — `[fockSugawara m, mode s a] = ((−s : ℤ) : F) • mode (m+s) a` for every
  `a : H F L`;
* **`fockSugawara_neg_one_creation`** — the target at `m = −1`: `[fockSugawara (−1), mode (−(k:ℤ)) a] =
  (k : F) • mode (−(k:ℤ)−1) a`, for `k : ℕ` (no `k ≥ 1` needed: `k = 0` is `0 = 0`);
* `fockSugawara_neg_one_creation_ofLattice` — the same at `a = ofLattice c`;
* **`sugawaraMode_neg_one_creation_basis`** — a new `V_L` corollary for the landed (8.4.7)-factor
  Sugawara, from the landed `MM.FLM87FC.sugawaraFoldIdentity` (`MMFLM87SugawaraFoldClose.lean:320`,
  which closed the old `SugawaraFoldIdentity` gap) together with
  `MM.FLM87ZBK.fockSugawaraVL_comm_modeVL` (`MMFLM87ZeroModeBracket.lean:507`); this composition was
  not landed before.

**The exact remaining residual for `htrans`.**  The corrected (`Yzero`) state half is **not** assembled:
the file lands the named `Prop`

    ZeroPartCreationCommutes : ∀ k i,
      MM.FLM87ZD.zeroPart (−1) * modeVL (bL i) (−(k:ℤ))
        − modeVL (bL i) (−(k:ℤ)) * MM.FLM87ZD.zeroPart (−1) = 0

together with `correctedStateHalf_of_zeroPart`, which derives `CorrectedStateHalf` (the
`sugawaraModeZero` form, basis labels) from it via the landed decomposition
`sugawaraModeZero n = fockSugawaraVL n + zeroPart n` (`MMFLM87FockZero.lean:225`, `:260`).  Closing
`ZeroPartCreationCommutes` is `MM.FLFock.mode_commutator` at `(−1, −k)` (which vanishes for `k ≥ 1`)
plus `hZeroVL_mul_modeVL_comm` — a `V_L` tensor-factor computation, deliberately left out of this file.
To finish `LMinusOneCreationMode` from there one still needs the `hY` identification
(`MM.FLM87SA.LOf_eq_sugawaraModeZero`) and the step from basis labels to arbitrary `b ∈ L`
(`MM.FLM85LL.modeVL_add` plus integral combinations).  **Translation is therefore two small steps and
one tensor-factor computation from closed.**

**V1 ACCEPTED — `Definitions/MMFLM810StateHalfClose.lean`** (300 lines, namespace `MM.FLM810SHC`, 9
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  **The state half of (8.10.13) is closed**, and the
translation field's remaining content is now a single named field identity.

**Landed.**  `zeroPartCreationCommutes` (so `MM.FLM87SH.ZeroPartCreationCommutes` **is a theorem**),
`zeroPart_comm_creation` at an arbitrary lattice label, `correctedStateHalf` (from the landed
`correctedStateHalf_of_zeroPart`), the general form `correctedStateHalf_general :
[sugawaraModeZero (−1), modeVL b (−(k:ℤ))] = (k:F) • modeVL b (−(k:ℤ)−1)` for **every `b : L`**, and
— the headline —

    lMinusOneCreationMode : MM.FLM810TG.LMinusOneCreationMode bL form hnd E

so the named state half is a theorem at arbitrary `b`, arbitrary vector, with no symmetry hypothesis.
The bridge that made it work is a new `vacuumNormalized_baseRepaired` (from `baseRepaired_zero` plus
field extensionality) feeding the landed `LOf_eq_sugawaraModeZero`.

**The fourth "already landed under an unguessed name" case, and the rule is now firm.**  The route the
brief proposed (`MM.FLFock.mode_commutator` at `(−1,−k)` plus `hZeroVL_mul_modeVL_comm`) was
**superseded**: the target already existed as `MM.FLM87ZBK.zeroPart_comm_modeZ`
(`Definitions/MMFLM87ZeroModeBracket.lean:257`), for **all** `(n,m)` and all labels, so neither
computation was needed and `k = 0` is covered too.  The rule, now stated three times in this ledger and
once in `AGENTS.md`: **before proving an identity, grep all of `Definitions/` for its statement shape**,
not the files whose names suggest it.

**The translation field, exactly.**  `TranslationOnStateData` is **not** a theorem, and the brief's hope
that the state half would yield it is **wrong**: `translationOnStateData_iff_translationResidual`
reduces the predicate to a **field** identity,

    TranslationResidual (bL) (form) (hnd) (E) : Prop :=
      ∀ D m, Yzero (baseRepaired E) (sugawaraModeZero (−1) (stateOfVL D)) (−m−1)
               = (dFold (datumFactorsZero D) (baseRepaired E D.a)).fam (−m−1)

whose two missing halves are named and independent of the state half: (i) the **base case**
`D = ⟨[], a⟩`, *equivalent* to the unproved `MM.FLM84LT.generalStateDeriv`
(`MM.FLM810TG.baseStateTranslation_iff_generalStateDeriv`); (ii) the **creation intertwining**
`Yzero (α_b(−n) w) = actionFamily (factor n b) (Yzero w)` at arbitrary `w`
(`MM.FLM810TRS.translationFieldHalfStatement`, unproved; the only landed instance is
`MM.FLM810TR.Yzero_modeVL_eq_actionFamily`, the single case `α_a(−1) ι(a)` at the model base).

**A tested trap, recorded.**  The Finset/`sum_repr` route for basis-labels-to-arbitrary-`b` is a trap in
this pin: `Module.End F (VL F L)` carries `LinearMap.instSub`/`LinearMap.instSMul`, so
`sub_eq_iff_eq_add'`, `smul_sub`, `Finset.sum_sub_distrib` and `sub_self` do **not** fire, and
`rw [modeVL_add]` rewrites only the first index it matches (the explicit `n` binder leaves one
metavariable).  The working route is `Submodule.span_induction` on `bL.span_eq` in the **addition** form,
recovering the subtraction form at the vector level.

---

### Batch 163 — the owner's standing instruction: **do not stop until Theorem 8.10.2 is complete**

Owner's instruction (2026-09-20, on leaving the session): *"Theorem 8.10.2 没完成不要结束"* — the campaign
is **not** to be concluded until Theorem 8.10.2 is done, definitions aligned to the book.  Two tasks were
dispatched, on disjoint files, against the two remaining reducible inputs:

* **W1 `Definitions/MMFLM810CreationIntertwine.lean`** (`MM.FLM810CI`) — the **creation intertwining**
  `Yzero (α_b(−n) w) = actionFold [factor n b] (Yzero w)` at arbitrary `w`, i.e. the **field half** of
  `MM.FLM810SHC.TranslationResidual`, generalising the single landed case
  `MM.FLM810TR.Yzero_modeVL_eq_actionFamily` (the case `α_a(−1) ι(a)` at the model base).  Together with
  the base case (`MM.FLM84LT.generalStateDeriv`, equivalent to the base-state translation) this closes
  `htrans`.
* **W2 `Definitions/MMFLM87SugawaraBracketClose.lean`** (`MM.FLM87SBC`) — FLM **(8.7.9)**,
  `MM.FLM87SA.FreeBosonSugawaraBracketZero`: the Sugawara modes' Virasoro bracket with the forced
  central charge `dim 𝔥`, i.e. the **whole remaining content of `hvir`**.  The brief records that the
  two-statement route `MM.FLM87ZBC.virasoroOnStateData_of_named` is **dead** (that file's own §4b
  measures its second statement untenable) and that the Fock-level bracket may already be landed in
  `Definitions/MMFockVirasoro.lean` — which is exactly the file that carried the Fock-level
  `L_commutator_alpha` that batch 161 needed.

**Standing rules for every remaining batch** (restated so that any later reader can audit the campaign):
grep all of `Definitions/` for a statement's **shape** before proving it (four targets have already been
found landed under unguessed names); never use a refuted object (`heisFam`, `modelBase`,
`tailLeibnizResidual`, `IsHomogeneousOp`, `Display8625`, `CrossContraction`, `Contraction8612Ratio`,
`ResidueUMulCompatibilityStatement`, `OperatorDisplay8620Statement`, `RelSpanningStatement`,
`QuadrantResidueStateFree`); verify every `file:line` with `grep -n`; budget discipline (a named residual
beats an unfinished file); and the dispatcher rebuilds every handed-back file from a deleted `.olean`
before accepting it.

**Where Theorem 8.10.2 stands at this entry** (the exact inventory, all names landed and verified):
`hL0` **discharged**; `htrans` = the named `MM.FLM810SHC.TranslationResidual`, whose two halves are the
base case (`generalStateDeriv`) and W1's intertwining; `hvir` = the named
`MM.FLM87SA.FreeBosonSugawaraBracketZero` (W2); `hjac` = `M JacobiOnStateTargets`, open, with the `n = 2`
`ι` maps landed (`MM.FLMIotaVar`) for the `l ≠ 0` faces and the finite-support carrier blocking the
negative-pairing case of the `l = 0` face.

**W2 ACCEPTED — `Definitions/MMFLM87SugawaraBracketClose.lean`** (294 lines, namespace `MM.FLM87SBC`, 6
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  **Theorem 8.10.2 now has `hvir` discharged as well —
modulo one hypothesis that the intended lattices cannot satisfy, which is the batch's finding.**

**The finding, and it is structural.**  FLM (8.7.9) at `c = dim 𝔥` was **already a theorem**
(`MM.FLM87ZBF.freeBosonSugawaraBracketZero_of_orth`,
`Definitions/MMFLM87ZeroModeBracketFinal.lean:357`, batch 117), from
`hOrth : MM.FLM87ST.OrthonormalBasis bL form`; and `MM.FLM87SG.sugawaraCollapse_iff_orthonormal`
(`:555`) shows the alternative hypothesis `SugawaraCollapse` is **equivalent** to `hOrth`.  So nothing
new was needed at `c = dim 𝔥` — what is genuinely open is the bracket with `hOrth` **removed**.  And:

    not_orthonormalBasis_of_even : (∀ a, 2 ∣ form a a) → (i : κ) → ¬ OrthonormalBasis bL form

**`hOrth` is FALSE on every even lattice** — FLM's (8.7.3) asks for an orthonormal basis of the
`F`-vector space `𝔥 = L ⊗ F` (where scaling by `1/√(b_i,b_i)` is allowed), whereas the repository's
predicate demands it of the **`ℤ`-basis `bL`**, which is unsatisfiable as soon as some `(b_i,b_i)` is
even.  **So the landed producer covers only odd lattices, and not the Leech lattice of Theorem
8.10.2.**  This is the fifth "the target was landed under an unguessed name" case, and the first where
the landed form turns out to be *unusable for the intended object* rather than merely equivalent.

**Landed here.**  `freeBosonSugawaraBracketZero_dimH` (the bracket at `c = card κ`, routed through the
landed `MM.FLM87ZP.freeBosonSugawaraBracketZero_of_named` plus the Fock and zero-mode brackets);
**`virasoroOnStateData_aligned_dimH`** — `hvir` **with no bracket hypothesis**, at
`Yzero (baseAligned E)`, central charge `dim 𝔥` — the brief's assembled form;
**`theorem8102_of_generatorFieldsAligned_dimH`** — **Theorem 8.10.2 with `hvir` and `hL0`
discharged**; `rankStatement_card`; and
`not_freeBosonSugawaraBracketZero_of_centralCharge_ne` (the bracket at any other central charge is
**false**, so `dim 𝔥` is forced).

**The exact residual.**  `MM.FLM87SBC.SugawaraBracketAtDimH bL form hnd := FreeBosonSugawaraBracketZero
bL form hnd ↑(card κ)` **without `hOrth`**.  It is unreachable from the landed route because the bridge
`sugawaraModeZero = fockSugawaraVL + zeroPart` is **false** without `hOrth`
(`MM.FLM87ZDGC.not_generalSugawaraDecomposition`,
`Definitions/MMFLM87ZeroModeDecompGeneralCounter.lean:318`, the rank-one `⟨b,b⟩ = 2` counterexample at
`n = 1`), and the collapse behind it is equivalent to `hOrth` (batch 118).  Closing it requires a **new
Gram-weighted Sugawara bracket** (dual-basis pairing `[h'_i(m), h_j(n)] = m δ_ij δ_{m+n,0}`); the agent
flagged, as an explicitly unverified idea, that the bracket may use only the cross pairing and so might
be a transport of the orthonormal one along the Gram twist.  **That is the next task on the Virasoro
front.**

**Brief errors.**  The brief called (8.7.9) open — it is landed since batch 117, and **not** in
`MMFockVirasoro.lean`, which carries only the Heisenberg-level `L_commutator_L`; the `V_L`-level
transport is `MM.FLM87ST.fockSugawaraVL_bracket`.  The arbitrary-`c` target is false.  And the
prescribed decomposition silently requires `hOrth` — which is where the entire gap sits.  The brief's
route audit was otherwise right: the `MM.FLM87ZBC` named route is dead
(`:245`, `:257`) and the direct route is alive.

**W1 ACCEPTED — `Definitions/MMFLM810CreationIntertwine.lean`** (417 lines, namespace `MM.FLM810CI`, 12
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  **The creation intertwining is now a theorem at
arbitrary `w`** — the induction step of the translation field.

**Landed.**  `Yzero_modeVL_eq_actionFamily_nat (base) (n ≥ 1) (b) (w)`:

    Yzero base (modeVL b (−(n:ℤ)) w) = actionFamily (factorFactorZero n hn b) (YzeroField base w)

at **arbitrary `w`** — together with the `ℕ+` form, the lattice-generator specialisation at an arbitrary
base, the `α_a(−1) ι(a)` case at an arbitrary base, and a recovery of the landed model-base theorem.
The supporting machinery is new and worth naming: `Yzero_trunc` — **(8.5.6) at an arbitrary vector**
(`Yzero base w` is lower truncated, from `Submodule.span_induction` over the landed
`MM.FLM85Un.spanningStatement`) — which is what makes the bundling `YzeroField` possible;
`actionFamilyZero` (linearity of `w ↦ actionFamily X (YzeroField base w)`); `actionPrescriptionTAZero_cons`.

**A type correction the brief needed.**  `FLM85TA.actionFamily` consumes a **`TruncatedField`**, not a bare
coefficient family, so the brief's literal shape `actionFold [factor n b] (Yzero w)` is **not typable**;
the file introduces `YzeroField base w` (whose `fam` is `Yzero base w` by `rfl`) as the object the
action consumes.  That bundling is exactly what `Yzero_trunc` buys.

**What does *not* follow, and this is the honest state of the translation field.**  `TranslationResidual`
is **not** proved: the intertwining is its **induction step** only.  The base case is landed as the named
`Prop` `BaseResidual`, with two machine-checked reductions — `baseResidual_iff_actionFamily_base` (the
base case is equivalent to the base-field identity `actionFamily (baseFactor a) (base a) = dField (base a)`,
i.e. to the still-open `MM.FLM84LT.generalStateDeriv`) and `translationResidualBase_iff_baseResidual` (the
`sugawaraModeZero` spelling).  The remaining `dFold` assembly needs two pieces the file names and does
**not** claim: (a) the factor recurrence `dFactor (factor n b) = n • factor (n+1) b` as bundled `Factor`s
(`MM.FLM810TRF.factorFamilyZero_deriv` is for the bare family; there is no scalar action on `Factor` and
no `actionFamily` congruence in `Factor.bound`), and (b) the derivation form of the state half at
`sugawaraModeZero`.  **So `htrans` is now: the induction step (proved) + the `dFold` assembly (two named
pieces) + the base case (equivalent to `generalStateDeriv`).**

**Brief errors.**  The landed case the brief called unique
(`MM.FLM810TR.Yzero_modeVL_eq_actionFamily`) is really `MM.FLM810TC.…`
(`Definitions/MMFLM810TranslationCorrected.lean:121`), and a **second** instance was already landed under
an unguessed name — `MM.FLM810TRS.Yzero_modeVL_iotaVL`
(`Definitions/MMFLM810TranslationDerivationState.lean:74`, the lattice-generator case `α_a(−n)ι(c)`,
`n ≥ 1`), so the brief's ladder would have reproved it.  That is the fifth unguessed-name case, and it is
a reminder that the grep rule must be applied to the **statement shape**, not to a guessed identifier.

**X1 ACCEPTED — `Definitions/MMFLM87GramSugawara.lean`** (300 lines, namespace `MM.FLM87GS`, 9 guards;
verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  The task was dispatched to close the Virasoro residual
for the Leech case; it came back with a **refutation of the only proposed shortcut**, which is the result
that matters.

**The Gram-twist transport idea is FALSE, in both readings, and both are now theorems.**

* `form_eq_of_gramTwist` — if an `F`-linear equivalence `S` of `V_L` conjugates the `form`-modes to the
  `form'`-modes (the generator-level twist `h_i ↦ h'_i`, with **no** algebra-map hypothesis), then
  `form' = form` on all lattice pairs.  The mechanism is exact: conjugation preserves the central
  coefficient `m⟨a,b⟩` of the CCR (7.1.5) `MM.FLM85MC.modeVL_mul_modeVL_eq`, so the form cannot change.
* `not_gramTwist_rankOne_even` — no such equivalence between `MM.FLM87ZDGC`'s `formOne` (`⟨b,b⟩ = 1`) and
  `formTwo` (`⟨b,b⟩ = 2`) over `ℚ` (it would force `2 = 1`).
* `not_exists_rat_two_mul_sq_eq_one` + `not_orthonormalVector_rankOne_even` — `2c² = 1` has no rational
  solution, so the "extend `F` if necessary" reading of FLM (8.7.3) needs `√2` and therefore **is**
  (8.7.3) rather than a way around it; and independently, `sugawaraModeZero` is built from the (8.4.16)
  folds of the **`ℤ`-basis** fields, so an orthonormal `F`-basis of `𝔥` could not be fed to it without
  redoing (8.7.5) for that basis.

**The residual is unchanged and now precisely located.**  `MM.FLM87SBC.SugawaraBracketAtDimH bL form hnd`
(FLM (8.7.9) at `c = card κ`) is **not** a theorem, and the repository has **no route** to it: the only
landed producer demands exactly the refuted hypothesis (the measured first error is
`don't know how to synthesize placeholder for argument 'hOrth'`, goal `⊢ OrthonormalBasis bL form`), and
`MM.Heisenberg.L_commutator_L` is stated only for the **identity** Gram while `MM.FLM87ST.fockSugawaraVL`
carries **no form argument** at all (it is the orthonormal-form Sugawara in the `bL` coordinates).  So the
general case is **not** a transport: it needs a new **two-contraction** mode computation — the dual pair
`(b_i, u^i)` of FLM (8.7.2) — and the file names the smallest open case as
`RankOneEvenSugawaraBracket` (`SugawaraBracketAtDimH` at `MM.FLM87ZDGC.formTwo` over `ℚ`, with
`rankOneEvenSugawaraBracket_iff : … ↔ FreeBosonSugawaraBracketZero … ↑(card Unit)`, `Iff.rfl`, so the
named case is exactly the target and not a weakening).  Landed starting points for that computation are
cited in the file's §5: `MM.FLM810CV.dualCoeff`, `MM.FLM810ZM.dualHBasis_sum`,
`MM.FLM810ZMT.dualCoeff_sum_smul_hBasis`, the unconditional decomposition
`MM.FLM87ZDG.sugawaraModeZero_apply_eq_regular_add_zeroCorr` with `MM.FLM87SG.zeroCorrPart`, and the
Gram-weighted `[Z,Z]` bracket `MM.FLM87ZBK.zeroPart_comm`; **the missing piece is the bracket of the
regular inverse-Gram part.**

**Brief errors.**  `dualCoeff` is `MM.FLM810CV` (`Definitions/MMFLM810ConformalVector.lean:98`), not
`MM.FLM87SA`; the flagged shortcut was not merely unverified but **false**; and the brief's
"Fock-level first" is not the cheap step it looks like, for the reason above.  The brief's other
references checked out.

**Y2 ACCEPTED — `Definitions/MMFLM810DFoldAssembly.lean`** (355 lines, namespace `MM.FLM810DFA`, 9
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  **`TranslationResidual` is now ASSEMBLED** — the
induction, the intertwining and the fold bookkeeping are no longer part of the translation gap.

**Piece (1) LANDED, and its true shape differs from the brief's.**

    factorSmul (n : ℕ) (X : Factor F L) : Factor F L            -- the MISSING scalar action on Factor
      (fam := (n:F) • X.fam, nil/vac inherited at the SAME bound, since the ^+ half of n•X is n•(X^+))
    dFactor_factorFactorZero : dFactor (factorFactorZero n hn b) = factorSmul n (factorFactorZero (n+1) … b)
    actionFamily_dFactor_factorFactorZero : actionFamily (dFactor (factor n b)) Y m
                                          = (n:F) • actionFamily (factor (n+1) b) Y m

The brief's literal `dFactor (factor n b) = n • factor (n+1) b` is **not type-correct** (there is no
`SMul` on `Factor` — that is why `factorSmul` had to be built), and the library's landed recurrence is in
the **chain-rule orientation** `X_{n+1} = (n:ℚ)⁻¹ • deriv X_n`, so the `F`-scalar form needs both the
`ℚ → F` bridge (not `rfl`: the `ℚ`-action on `V_L` is the tensor-product left action, proved here via
`nsmul`) and a cancellation of `n`.  `MM.FLM810CI` §5(a) is thereby closed; the bound issue is resolved by
`MM.FLM85AA.tailWindow_eq_of_kills` window comparison rather than by a congruence.

**Piece (2) NAMED, not discharged — and the reason is a finding.**  `SugawaraDerivation` is landed as a
named `Prop`, with `sugawaraDerivation_iff_lMinusOneCreationMode` showing it is **exactly** the landed
`MM.FLM810TG.LMinusOneCreationMode`, plus the consumed form `Yzero_sugawaraModeZero_modeVL` conditional on
it.  It could not be discharged here because **the only landed proof of the state half carries
`hOrth : OrthonormalBasis`** (`MM.FLM810SHC.lMinusOneCreationMode`, verified by the dispatcher at
`Definitions/MMFLM810StateHalfClose.lean:226`--`:228`) — and `hOrth` is false on even lattices.  So the
translation field and the Virasoro field share **one and the same** open input: the non-orthonormal
Sugawara computation.  A useful by-product: **the state half is `E`-independent** (the
`LOf`/`sugawaraModeZero` bridge carries no central extension).

**The assembly LANDED.**

    translationResidual_of_baseResidual : (hs : form symmetric) → BaseResidual (baseRepaired E)
                                        → SugawaraDerivation → MM.FLM810SHC.TranslationResidual
    translationResidual_iff_baseResidual : TranslationResidual ↔ BaseResidual
    translationOnStateData_of_baseResidual : MM.FLM810RR.TranslationOnStateData

**So `htrans` is now exactly two named inputs**: (i) `MM.FLM810CI.BaseResidual (baseRepaired E)`,
equivalent to the unproved `MM.FLM84LT.generalStateDeriv`; and (ii) `SugawaraDerivation` — i.e. the state
half **without** `hOrth`, which is discharged by *closing `MM.FLM87SBC.SugawaraBracketAtDimH`*
(batch 165's task Y1).  The two remaining fronts have therefore **merged into one**: the
two-contraction Sugawara computation, plus the single base-case identity.

**Y1 ACCEPTED — `Definitions/MMFLM87SugawaraTwoContraction.lean`** (509 lines, namespace `MM.FLM87TC`, 7
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  The non-orthonormal Sugawara computation — now the
**single shared blocker** of the Virasoro and translation fields — has its `[L, mode]` half landed and its
remaining computation named to the lemma.

**LANDED: the Witt action at an arbitrary basis, no `OrthonormalBasis`.**

    sugawaraModeZero_mul_modeZ_sub : [sugawaraModeZero m, modeZ (bL l) n]
                                   = (((−n : ℤ)) : F) • modeZ (bL l) (m + n)

for an **arbitrary `ℤ`-basis** and an **arbitrary symmetric form** — i.e. the first half of FLM (8.7.9),
and the first landed object in the repository that does not carry `hOrth`
(`MM.FLM87ZBK.fockSugawaraVL_comm_modeVL` and `MM.FLM810SHC.correctedStateHalf_general` both do).
Supporting landings: the corrected (7.1.33) **CCR** `modeZ_mul_modeZ_sub` (including the lattice zero
mode), the one-contraction pair identity `normalOrderedHeisPairZero_mul_modeZ_sub`, the Gram collapses
`inverseGram_collapse_left`/`_right` (+`_smul`), and the two contraction coefficients
`gramContraction`, `gramContraction_transpose`, `normContraction`.

**The exact residual, named**: `MM.FLM87TC.RegularInverseGramBracket` — FLM (8.7.9) for
`MM.FLM87SA.sugawaraMode` (the regular inverse-Gram part, the first summand of the landed unconditional
decomposition `MM.FLM87ZDG.sugawaraModeZero_apply_eq_regular_add_zeroCorr`) at `c = card κ`.  **The one
computation that remains is the double commutator**
`[:b_i(m−p)b_j(p):, :b_k(n−q)b_l(q):]`, where both contractions occur at once.  A second, separate gap was
measured: the brackets mixing `sugawaraMode` with `zeroCorrPart` are **not even statable today**, because
`zeroCorrPart` is a plain function rather than an endomorphism and the landed decomposition is pointwise
— a linearity statement for it is missing from the repository.

**The contraction picture, corrected from the brief's.**  In the bracket the brief asked for first, the
**Gram contraction** `Σ_j (M⁻¹)_{ij}⟨b_j,b_l⟩ = δ_{il}` is the *only* contraction, and it enters **twice**
— at `k = −n` against the first factor of `:b_i(m−k)b_j(k):` (coefficient `M_{il}`) and at `k = m+n`
against the second (coefficient `M_{jl}`) — each half contributing `−n·b_l(m+n)/2`, so that the outer
`(1/2)` of (8.7.5) is exactly what makes the halves sum to `−n·b_l(m+n)` rather than `−2n·b_l(m+n)`.
The **trace** `Σ_{ij}(M⁻¹)_{ij}⟨b_i,b_j⟩ = card κ` does **not** occur in `[L,mode]` at all: it is the
contraction *inside* one normal-ordered pair, so it can only appear in the self-bracket's double
commutator — **and that is where the central charge `dim 𝔥` comes from**.

**More brief corrections of record.**  `MM.FLM87GS` is not a file name (the namespace lives in
`Definitions/MMFLM87GramSugawara.lean`) — `grep` beats a guessed path.  The transport obstruction is
stronger and more concrete than batch 164's `form_eq_of_gramTwist` alone: `modeZ`'s dependence on `form`
sits **only in the annihilation half** (creation for `m < 0`, `derivOf (hForm …)` for `m > 0`), so any
transport would have to scale creation by `1` and annihilation by `λ` — no conjugation can do that, so
the two-contraction computation is unavoidable for coefficient-level reasons as well.  And
`RankOneEvenSugawaraBracket` is **not** the easier first milestone: `κ = Unit` does not simplify the
double commutator, because the difficulty is the normal-ordering/double-contraction algebra, not the rank
— so "smallest case first" buys no shorter proof here.

**Z1 ACCEPTED — `Definitions/MMFLM87DoubleCommutator.lean`** (346 lines, namespace `MM.FLM87DC`, 3
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  The double commutator is classified, and the task
**found a shorter route to (8.7.9)** that avoids it.

**Landed: the one-contraction layer for the double normal-ordered pair.**
`mul_mul_mode_sub` (the plain-product form, exact) and
`normalOrderedHeisPairZero_mul_normalOrderedHeisPairZero_sub` (the normal-ordered form with the scalar
`doubleContraction`), with the supporting `pairDefect`/(D) in both directions,
`normalOrderedHeisPairZero_eq_mul_sub`, `mode_mul_mode_eq_pairZero_add`, `commutator_mul_mul`,
`sub_smul_one_mul_smul_one`.

**The classification, and it corrects the brief's picture** (with `P_cd(N,r) = :b_c(r)b_d(N−r):`,
`M_cd = ⟨b_c,b_d⟩`, and `[AB,CD] = A[B,C]D + AC[B,D] + [A,C]DB + C[A,D]B`): exactly **four** terms, one per
index combination — `(j,k)` coefficient `(m−p)M_jk`, delta `m−p+q = 0`, leftover `b_i(p)b_l(n−q)` (cross);
`(j,l)` coefficient `(m−p)M_jl`, delta `m+n−p−q = 0`, leftover `b_i(p)b_k(q)` (**transpose-Gram**);
`(i,k)` coefficient `pM_ik`, delta `p+q = 0`, leftover `b_l(n−q)b_j(m−p)` (cross); `(i,l)` coefficient
`pM_il`, delta `p+n−q = 0`, leftover `b_k(q)b_j(m−p)` (**Gram**).  There is **no fifth "no contraction"
term** (the four-fold product cancels identically), and re-ordering the leftovers into normal-ordered
pairs adds **one scalar** `doubleContraction` = `c₁z₁+c₂z₂+c₃z₃+c₄z₄`, where each `z_r` is the defect
`Q−P` of that leftover — **and that is the only place two contractions meet**: it is supported on
`m+n = 0`, its index patterns are `M_il M_jk` and `M_ik M_jl`, and the inverse-Gram contraction of those
is `Σ_{ij}(M⁻¹)_{ij}M_{ij} = card κ` (`MM.FLM87TC.normContraction`).  The agent also verified the end
result independently in an exact Weyl-algebra model (156816 cases, no failures) and checked
`[L(m),L(n)] = (m−n)L(m+n) + (m³−m)·card κ/12·δ` on the Fock model.

**The route correction, which is the batch's most useful finding.**  The double commutator is **not** on
the shortest path.  The product rule `[L,XY] = [L,X]Y + X[L,Y]`, the landed Witt action
`MM.FLM87TC.sugawaraModeZero_mul_modeZ_sub`, and the defect (D) give, **with no pair–pair commutator at
all**,

    [L(m), P_kl(n,q)] = −q·P_kl(m+n, m+q) − (n−q)·P_kl(m+n, q) + δ(q)·1

with `δ` supported on `m+n = 0`, `δ(q) = −q(m+q)M_kl` for `q ≤ 0 < m+q` and `+q(m+q)M_kl` for
`m+q ≤ 0 < q` (exactly `|m|` values of `q`).  That is landed as the named `Prop`
`MM.FLM87DC.PairVersusSugawaraBracket`.  After it, only two steps remain for `SugawaraBracketAtDimH`:
(i) the `q`-sum reindexing with `MM.FLM87ZDG.sugawaraModeZero_apply_eq_sum_pairZero` (the two `P`-terms
give `(m−n)L(m+n)`), and (ii) the finite interval sum `Σ_q δ(q) = (m³−m)M_kl/6` together with the collapse
`Σ_{kl}(M⁻¹)_{kl}M_{kl} = card κ`, giving the central term `(m³−m)·card κ/12`.  **This bypasses the
double commutator entirely** — the classification above is now the record of a computation that does not
need to be assembled.

**Brief errors of record**: the brief's "the Gram enters twice at `k = −n` and `k = m+n` with coefficients
`M_il` and `M_jl`" is batch 165's *`[L,mode]`* bookkeeping, not the pair–pair commutator (where the
Gram-type pairings sit at `p+n−q = 0` and `m+n−p−q = 0`, with two further **cross** contractions `M_ik`,
`M_jk`); the "double contraction" is one delta coefficient times a normal-ordering defect, **not** a
product of two deltas; and `RegularInverseGramBracket` is **not** an intermediate for the corrected
`SugawaraBracketAtDimH`, because the mixed `zeroCorrPart` brackets are not formal — so the residual
targets the corrected case directly.  The file is 346 lines (the coefficient layer is in, the assembly
deliberately is not; nothing was weakened).

**A1 ACCEPTED — `Definitions/MMFLM87SugawaraShortRoute.lean`** (1094 lines, namespace `MM.FLM87SR`, 15
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  **THIS IS THE CAMPAIGN'S LARGEST SINGLE RESULT: FLM
(8.7.9) is proved at an arbitrary basis with NO `OrthonormalBasis`, and with it the Virasoro field of
Theorem 8.10.2 is closed for the Leech lattice, and the state half of the translation field falls too.**

**Landed, in the order of the route.**

* `pairVersusSugawaraBracket_holds (bL) (form) (hnd) (hs) : MM.FLM87DC.PairVersusSugawaraBracket` —
  batch 166's residual is **a theorem**, from the product rule + the landed Witt action
  `MM.FLM87TC.sugawaraModeZero_mul_modeZ_sub` + the defect (D).  **The double commutator is not used at
  all** — batch 166's classification stands as the record of a computation that turned out to be
  unnecessary.  Helpers: `mul_mul_sub_mul_mul`, `pairDefect_add_reversePairDefect`, and a **new
  reverse-order** (D) `reverse_mode_mul_mode_eq_pairZero_sub`.
* **Summation (1)**: `finsum_comp_add` (finsum over `ℤ` is translation-invariant), `finsum_pairZero_shift`,
  `finsum_pairZero_two_terms : Σᶠ_q ((−q)•P(m+n,m+q)v − (n−q)•P(m+n,q)v) = (m−n) • Σᶠ_q P(m+n,q)v`.
* **Summation (2)**: `straddle`, `pairVersusSugawaraDefect_eq_straddle`, `antiQuad`,
  `sum_range_quadratic`, `finsum_straddle : Σᶠ_q straddle m q = (m³−m)/6`, and
  `finsum_pairVersusSugawaraDefect : Σᶠ_q δ(q) = (if m+n = 0 then (m³−m)·(6:F)⁻¹·M_kl else 0)`, with
  `δ` supported on exactly the `|m|` integers strictly between `0` and `−m` (uniform window
  `min (1−m) 1 ≤ q ≤ max 0 (−m)`), equal to `−q(m+q)M_kl` on `q ≤ 0 < m+q` and `+q(m+q)M_kl` on
  `m+q ≤ 0 < q`.
* **THE HEADLINE**: `sugawaraBracketAtDimH (bL) (form) (hnd) (hs) : MM.FLM87SBC.SugawaraBracketAtDimH`
  — i.e. `FreeBosonSugawaraBracketZero` at `c = card κ` **with no `hOrth`**.  The assembly is the
  pointwise expansion `sugawaraModeZero_apply_eq_sum_pairZero` + `pairVersusSugawaraBracket` + the two
  summations + `MM.FLM87TC.normContraction`, with the central charge `(m³−m)·card κ/12` obtained exactly
  as batch 166 predicted: the `q`-sum reindexes (`q ↦ q+m`) to `(m−n)·Σ_q P_kl(m+n,q)`, which the outer
  inverse-Gram collapse turns into `(m−n)L(m+n)`, and `Σ_{kl}(M⁻¹)_{kl}M_{kl} = card κ` supplies the
  central term.
* **Both payoffs reached**:
  `virasoroOnStateData_aligned_dimH_noOrth : VirasoroOnStateData … (Yzero (baseAligned E)) … (card κ : ℚ)`
  (the `hOrth`-free form of batch 163's `virasoroOnStateData_aligned_dimH`, via the landed
  `MM.FLM87SA.virasoroOnStateData_of_freeBosonBracketZero`), **and** the state half:
  `correctedStateHalf_basis`, `correctedStateHalf_noOrth`,
  `sugawaraDerivation : MM.FLM810DFA.SugawaraDerivation …`, and
  `lMinusOneCreationMode_noOrth : MM.FLM810TG.LMinusOneCreationMode …` — **no `hOrth` anywhere**, built
  from the `m = −1` Witt action plus `ℤ`-linearity of `modeVL`, then the landed
  `sugawaraDerivation_iff_lMinusOneCreationMode`.

**Consequences for Theorem 8.10.2, and this is the state to resume from.**

| input | status |
| --- | --- |
| `hL0` (8.10.12) | **discharged** (batch 157) |
| `hvir` (8.10.9) | **discharged for arbitrary lattices** — `sugawaraBracketAtDimH` has no `hOrth`, so batch 163's `hOrth`-carrying form is superseded; |
| state half of `htrans` (8.10.13) | **discharged, no `hOrth`** — `lMinusOneCreationMode_noOrth`; |
| `htrans`'s base case | **open**: `MM.FLM810CI.BaseResidual`, equivalent to `MM.FLM84LT.generalStateDeriv`; |
| `hjac` (8.10.8) | **open**: `JacobiOnStateTargets`, no producer for any field; the `n = 2` `ι` maps are landed (`MM.FLMIotaVar`) for its `l ≠ 0` faces, and the `l = 0` face at `⟨a,b⟩ ≤ −2` needs a carrier that can express a contraction series. |

**A new tracked item**: because `hOrth` is now gone from the Virasoro route, batch 163's
`MM.FLM87SBC.virasoroOnStateData_aligned_dimH` / `theorem8102_of_generatorFieldsAligned_dimH` (which
carry `hOrth`) should be **restated** against `MM.FLM87SR.virasoroOnStateData_aligned_dimH_noOrth`, so that
`theorem8102_of_generatorFieldsAligned` has one fewer input.  That restatement is mechanical and is the
first task of the next batch.

**Brief corrections of record**: `pairVersusSugawaraBracket` cost ~90 lines, not the estimated ~40 (it
needs the new reverse-order defect and a vector-level finish); summation (1) does **not** need
`sugawaraModeZero_apply_eq_sum_pairZero` (it is about `normalOrderedHeisPairZero` alone); the working
support window is `min (1−m) 1 ≤ q ≤ max 0 (−m)`; `MM.FLM810DFA` is a namespace (the file is
`Definitions/MMFLM810DFoldAssembly.lean`); the state half was **not** derivable from the landed material
(`MM.FLM810SHC.correctedStateHalf` carries `hOrth`), so its basis-label case had to be redone from the
Witt action; and in this pin `rw [← smul_sub]`, `rw [← sub_smul]` and `rw [← finsum_smul]` **fail even at
the `V_L` level** (`smul_add` fires at the `End` level, but `smul_sub` does not) — the workaround is a
forward `rw [← h, smul_sub]` or `simp only`.  The file blew the 300-line budget (1094) because all four
items had to live in the single permitted file.

**B1 ACCEPTED — `Definitions/MMFLM810TheoremNoOrth.lean`** (300 lines, namespace `MM.FLM810TNO`, 6
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  **Theorem 8.10.2 now has exactly TWO open inputs.**

**The boundary, with the `hOrth` gone** (verbatim):

    theorem8102_of_generatorFieldsAligned_noOrth (hnd) (hs) (E) (S) (hpd) (hW) (hfin)
      (hjac : JacobiOnStateTargets bL form (vertexOpOfField (Yaligned bL form E)))
      (hbase : FLM810CI.BaseResidual bL form (baseRepaired bL form E)) :
      Theorem8102 form ((Fintype.card κ : ℕ) : ℚ)

**Exhaustive remaining inputs**: `E`, `S` (data); `hnd` (the non-degeneracy interface — a named
`def … : Prop`, **not** derivable from `hpd`); `hs` (the (7.1.1) symmetry — **not** implied by
`PositiveDefinite`, which constrains only the diagonal); `hpd`; `hW`, `hfin` (inputs of
`theorem8102_of_fields`); **`hjac` (8.10.8) — open, no producer for any field**; and **`hbase` (8.10.13
at its new frontier) — open, equivalent to the landed `MM.FLM84LT.generalStateDeriv`**.

**Discharged, i.e. no longer inputs**: (8.10.9) at `c = card κ`
(`MM.FLM87SR.virasoroOnStateData_aligned_dimH_noOrth`), (8.10.12)
(`MM.FLM810TA2.l0OnWeightGenerators_aligned`), the translation **state half**
(`MM.FLM87SR.sugawaraDerivation`), and `RankStatement` at `card κ` (so the boundary has **no `r`
parameter** — a fact the brief had missed).  No `OrthonormalBasis`, `SugawaraCollapse`,
`tailLeibnizResidual`, `IsHomogeneousOp` or `heisFam` occurs anywhere in the file.

**The residual, reduced to its sharpest form.**  Landed reductions: `baseResidual_iff_baseStateDeriv`
(the residual **is** the honest (8.4.23) at every vector), `generalStateDeriv_iff_baseResidual` (it is the
landed `MM.FLM84LT.generalStateDeriv`), and the sharpest of the three —

    def CreationModeStep (E) : Prop :=
      ∀ a m b n, 1 ≤ n → ∀ w, DerivDefect E a m (modeVL b (−n) w)
                                = modeVL b (−n) (DerivDefect E a m w)

with `baseStateDeriv_iff_creationModeStep` and `baseResidual_iff_creationModeStep` proving it **equivalent**
to the residual (the `ι(c)` case is the landed `MM.FLM84LT.generalStateDeriv_iotaVL`; the extension is
`MM.FLM85Un.spanningStatement`).  **So the last input of translation is: the (8.4.23) defect commutes with
every creation mode.**

**The missing lemma, named by the failure itself.**  Two attempts were made and reverted (no `sorry`
left).  The first stalled on the creation-list induction (`rw [ih]` → *"Did not find an occurrence of the
pattern `(DerivDefect …) (stateOfVL …)`"*).  The second, after unfolding the corrected fold, left exactly

    headOp X.fam Y m (α w) + tailOp X Y.fam m (α w) − deriv Y.fam m (α w)
      = α ((headOp X.fam Y m + tailOp X Y.fam m − deriv Y.fam m) w)

and `map_sub` failed on it (*"Did not find an occurrence of the pattern `?f (?a - ?b)`"*).  So the missing
input is **the commutator of a creation mode with the `headOp`/`tailOp` windows of the assembled
three-factor field** — no landed lemma computes `headOp`/`tailOp` at `modeVL b (−n) w`, and the landed
(8.4.23) (`MM.FLM85ZM.deriv_YCoeff_eq_opOpenBox_heisFamZero`) is the **model base**, i.e. the creation
half only (`MM.FLM810TC.deriv_modelBase_ne_flat_add_tail`).

**Brief errors of record**: the Virasoro/`L0` inputs live at `Yaligned E = Yzero (baseAligned E)` while
(8.10.13) is assembled at `baseRepaired E`, and the two are *family*-`rfl`-equal but **not**
definitionally equal as `TruncatedField`s, so the bridge `Yzero_baseRepaired_eq_Yaligned` had to be
landed; the object actually consumed is `translationOnStateData_of_baseResidual`, not the residual-level
form; and `c = card κ` silently discharges `hrank`.

**R1 ACCEPTED (reconnaissance) — `Probe/B169_R1_JACOBI.md` (152 lines).**  The true cost of `hjac` is now
measured, and two campaign assumptions are corrected.

**(1) `JacobiOnStateTargets` is EQUIVALENT to `MM.FLM810.JacobiAxiom` for *every* field** — not a weaker
state-restricted form.  `MM.FLM810JF.FaithfulJacobi Y.coeff u v`
(`Definitions/MMFLM810JacobiFaithful.lean:290`) is `JacobiOnStateTargets`'s body
(`Definitions/MMFLM810RemainingReduction.lean:166`--`:172`) with `w` ranging over **all** of `VL F L`
instead of over `Set.range (stateOfVL …)`; the backward direction is the landed
`jacobiAxiom_of_stateTargets` (`:180`, using the proved `MM.FLM85Un.spanningStatement`,
`MMFLM85Uniqueness.lean:600`), and the forward direction is a one-line definitional restriction (not
landed, and not needed).  **So the state-target restriction buys nothing: `hjac` *is* (8.10.8) at
`Yaligned`.**  The producer ledger is unchanged — six files mention it, all as definitions or hypotheses;
**no producer for any field**.

**(2) Both finiteness conjuncts of `hjac` are FREE at the boundary field.**  Truncation is landed
(`MM.FLM810TA2.componentTruncationAligned`, `Definitions/MMFLM810TheoremAligned.lean:121`) and the
window conjuncts follow from it (`crossWindowVectorwise_of_componentTruncation`,
`iterateWindowVectorwise_of_componentTruncation`, `Definitions/MMFLM810Axioms.lean:445`/`:452`), with the
assembly landed (`faithfulJacobi_of_crossWindowOn_stable`, `:464`).  **The entire cost of `hjac` is
therefore the component identity at a window past both vanishings** — and the window conjuncts cannot be
dropped, since at `N = 0` both sides are the empty sum
(`jacobiIdentity_zero_window`, `Definitions/MMFLM810JacobiNamedBridgeAux.lean:116`).

**(3) The `l = 0` face, verified.**  `MM.FLM86CI.commutator_YFam_eq_zero_of_even`
(`Definitions/MMFLM86CommIota.lean:186`) is unconditional at the even cocycle for `0 ≤ ⟨a,b⟩`, and
`commutator_rankOne_negTwo_ne_zero` (`:338`) is unconditional, with the carrier obstruction confirmed at
`not_locallyFinite2_contrFam_of_neg` (`Definitions/MMFLM86ProductExpansion.lean:351`) and
`ratioCoeff_ne_zero_of_neg` (`:236`).  Residue status: `0 ≤ ⟨a,b⟩` closes; `⟨a,b⟩ = −1` is closed form but
**conditional on `hY` *and* on `h851 = Corollary851` itself**
(`Definitions/MMFLM86IterateIota.lean:265`--`:296`); `⟨a,b⟩ ≤ −2` is unexpanded.  **The precise remaining
inequality** is the residue index `(i:ℤ) + form a b + 1 < 0`, i.e. `(i:ℤ) ≤ -form a b - 2`, where the
state `creationExpVL a (-(i:ℤ)-1-⟨a,b⟩) (anchorVL E a b)` is a positive-degree Fock descendant and **no
landed theorem evaluates `Y` at it** — the named gap `MM.FLM85IS.IterateProductStepOnCreated` =
`MM.FLM86SF.Display8610List` (8.6.10).  Only the top index `i = -⟨a,b⟩-1` is closed
(`iterateOf_lattice_boundary`, `MMFLM86IterateIota.lean:119`).

**(4) A structural surprise, and a correction to this campaign's own map.**  `MM.FLMIotaVar` (the `n = 2`
Hahn carrier landed in batch 156) is **isolated** — imported only by `FinalCheck.lean:386` — because the
§8.10 rationality layer uses a **different, already general-`n`** `ι`: `MM.FLM810.iota`
(`Definitions/MMFLM810Iota.lean:198`, with `iota_injective` at `:254`) and `toAllPerm`
(`Definitions/MMFLM810Theta.lean:121`).  Props 8.10.3/8.10.4/8.10.5/8.10.7 are all `def … : Prop` with a
TODO ledger (`Definitions/MMFLM810Rationality.lean:91`--`:297`) — stated, not proved — and the `ι`-image
existence half is recorded as not provable from repository data
(`Definitions/MMFLM810BridgeProduct.lean:37`--`:50`).  **`FLM-CH8-MAP.md`'s §8.10 rows (`:373`, `:434`,
`:437`--`:441`) are STALE** — they mark "missing" objects that are landed or at least stated; there is no
FLM-CH8 section in `ROADMAP.md`, and the live status is at `ROADMAP.md:4179`/`:3589`.

**(5) Verdict, and it is the honest one.**  `hjac` is **the open Jacobi identity at the honest field with a
currently-UNKNOWN route** — not "several more batches", and not "carrier plus rationality" in any form the
report could measure.  The largest fragment reachable today is the `l = 0` face at the lattice generators
for `0 ≤ ⟨a,b⟩` with the even cocycle, unconditional **up to one definitional link**: the (8.5.2) instance
`YFamOnGenerators … ((vertexOpOfField (Yaligned E)).coeff)`, which is **not landed**
(`Definitions/MMFLM85BaseFieldAligned.lean:46` records it as unproved) but follows from
`vertexOpOfField_coeff` (`Definitions/MMFLM810Fields.lean:180`) + `Yaligned_iotaVL`
(`Definitions/MMFLM85BaseFieldAligned.lean:297`) + `genFam_apply` (`:85`) + one `ring`.  **Recommended
single next batch item**: land that link, plus the `crossBracket`/`commutatorFamily` and
`crossIterate`/`iterateOf` dictionaries at `l = 0`, and then the `0 ≤ ⟨a,b⟩` corner — with the explicit
caveat that this does **not** make Theorem 8.10.2 unconditional.

**A note the agent flagged and the dispatcher confirms**: `Definitions/MMFLM810CreationCommute.lean`
appeared in `git status` during this reconnaissance and is **the sibling task's file, not R1's** — a
reminder that in a shared tree a `git add` must name its paths explicitly (which this campaign's commits
have done throughout).

**D1 ACCEPTED — `Definitions/MMFLM810JacobiZeroFace.lean`** (299 lines, namespace `MM.FLM810JZF`, 6
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  The reachable fragment of Jacobi is landed, and the
file produced **a producer for `Corollary851` itself** — which the reconnaissance had recorded as having
none.

**Landed.**  `yFamOnGenerators_vertexOpOfField_Yaligned` — the (8.5.2) instance for the boundary field, the
definitional link `Definitions/MMFLM85BaseFieldAligned.lean:46` had recorded as unproved — with the
helper `ZAligned E := (vertexOpOfField (Yaligned E)).coeff` and `ZAligned_apply` (`rfl`).  The three `l = 0`
dictionaries as thin re-exports at the boundary field (`crossBracket_zero_Yaligned`,
`crossIterate_zero_Yaligned`, `crossBracket_zero_iff_corollary851_Yaligned`, the last being the landed
`corollary851_iff_jacobiIdentity_zero_face` with its `hvan` discharged by a new
`bracketTerm_Yaligned_eq_zero_of_window` from `stateVanishesBelow_lattice`).  And the corner itself,
**unconditional**: `commutatorFamily_Yaligned_eq_zero`, **`corollary851_Yaligned_lattice_of_nonneg`** (for
the even cocycle `C`, `(2:F) ≠ 0`, symmetric form, `0 ≤ ⟨a,b⟩` — at **every** window `N`, which is stronger
than the brief's fixed-window sketch), and `crossBracket_zero_eq_crossIterate_Yaligned_lattice_of_nonneg`
(the `l = 0` component identity, LHS zero by `commutator_YFam_eq_zero_of_even`, RHS zero by
`corollary851Residue_eq_zero_of_nonneg`).

**The caution in the brief was checked and cleared, machine-verifiably.**  `YFamOnGenerators` was refuted
at the **model base** (batch 157); the file lands
`Yaligned_ne_Yzero_modelBaseField (E) (weight) (i) (c) (hp : form (bL i) c = -1) : Yaligned E ≠
Yzero (modelBaseField E weight)` and shows the refutation's witness has no analogue here — `Yaligned E`
reads `ι(a)` as `genFam E a = reflectFam (YFam E a)`, `ZAligned`'s definition *is* the (8.5.15) reindex,
so at `n = 0` both sides of the link are `YFam E a 0`.  `modelBase` occurs only inside the two separation
lemmas, never in a statement.

**What is explicitly NOT claimed.**  `⟨a,b⟩ = −1` remains conditional on `hY ∧ h851` (and that pair is
refuted at rank one); `⟨a,b⟩ ≤ −2` needs the (8.6.10) gap
(`MM.FLM86SF.Display8610List` / `MM.FLM85IS.IterateProductStepOnCreated`); `l ≠ 0`, arbitrary `u, v` and
the Fock half are untouched; and **`hjac` is not discharged** — no `FaithfulJacobi`/`JacobiAxiom`/
`JacobiOnStateTargets` statement occurs in the file.  The corner is a real theorem, not a reduction of the
whole identity.

**Brief corrections**: the item-3 sketch fixed the window at 1 (landed is every `N ≥ 1`, plus a producer
for `Corollary851`); and the `⇔` dictionary additionally needed the (8.5.11) finiteness at the generators,
which the file discharges rather than assuming.  The agent also notes that `AGENTS.md`'s build section
still says `tools/build.sh` is "NOT usable here" — **it is stale**, the driver works on this box, and the
claim should be corrected in the next ledger pass.

**C1 ACCEPTED — `Definitions/MMFLM810CreationCommute.lean`** (454 lines, namespace `MM.FLM810CC`, 6
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  It was dispatched to close the translation base case by
proving that the (8.4.23) defect commutes with creation modes; **it proved that claim false and found the
honest law**, which is a better result than the one ordered.

**The claim is false: the mode SHIFTS the field family, it does not commute with it.**  The classical law
is `[α_b(−n), Y(a,z)] = ⟨b,a⟩ z^{−n} Y(a,z)`, and the file lands its consequences window by window — the
three window commutators the brief asked for are all **false as asked**, and each has a landed exact
discrepancy in its place:

* `modeVL_headWindow_sub` (unconditional discrepancy) and `headWindow_modeVL_sub`
  (`= −⟨b,a⟩ • hW_{m+n}`);
* `modeVL_tailWindow_sub` (discrepancy = the field commutator plus the `^+`-half commutator) and
  `tailWindow_modeVL_sub` under the hypothesis `n ≤ M` (the window must contain the mode index):
  `tW(αw) − α tW(w) = −⟨b,a⟩•tW_{m+n} + (n⟨a,b⟩)•Y_{m+n+1}w`, with the pointwise input
  `modeVL_splitPlus_heisFamZero_sub` (at `k = 0` the (7.1.33) zero mode commutes; for `k ≥ 1` the
  discrepancy is `−n⟨b,a⟩δ_{k,n}`);
* `modeVL_deriv_sub` and `deriv_modeVL_sub` (`= −(m+1)•(⟨b,a⟩•Y_{m+n+1}w)`).

**The honest form of the translation target, and the residual it isolates.**

    window_carry : (hWα − α hW) + (tWα − α tW) − (dα − α d) = −⟨b,a⟩ • (hW_{m+n} + tW_{m+n} − d_{m+n})
    derivDefect_comp_modeVL_sub (hs) :
      DerivDefect E a m (α_b(−n) w) − α_b(−n) (DerivDefect E a m w) = −⟨b,a⟩ • DerivDefect E a (m+n) w
    creationMode_comm_iff_defect_shift (hs) :   -- with ⟨b,a⟩ ≠ 0
      (the fixed-mode commutation)  ↔  (∀ m w, DerivDefect E a (m+n) w = 0)

**So `CreationModeStep` is not an easier equivalent form of the base case — it is *exactly* (8.4.23) at
the shifted index.**  No window rule can close it, and `BaseResidual` / `generalStateDeriv` are unchanged.
The real missing lemma is now named:

    def CurrentFieldComm (E) : Prop :=
      ∀ a b n, 1 ≤ n → ∀ k,
        modeVL b (−n) * (baseRepaired E a).fam k − (baseRepaired E a).fam k * modeVL b (−n)
          = ((form b a : ℤ) : F) • (baseRepaired E a).fam (k+n)

with its pieces partly landed (creation modes commute with `E^-`,
`MM.FLM84CM.modeVL_comm_creationExpVL_int`; `a z^∂` acts on the lattice factor alone,
`MM.FLM84LF.midCoeff_mul_modeVL`) and two parts missing: the same commutator **with `E^+`** (a creation mode
acts on the annihilation exponential as a derivation) and pushing it through the two `convWith`s of `YFam`.

**The indexing trap, and it is the subtlest one this campaign has hit.**  `YFam` is the **reflected**
family (`baseRepaired_fam : (baseRepaired E a).fam k = YFam E a (−k−1)`), so **the shift reverses**: the
honest statement in the windows' indexing is `k ↦ k+n` with scalar `form b a`, while a `YFam`-indexed
`j+n` form is **false** (the correct `YFam` form is `j ↦ j−n`).  The agent's first statement of
`CurrentFieldComm` had the wrong indexing, and the error surfaced not as a type error but as a **`whnf`
timeout** in the assembly — cured by correcting the statement rather than by raising `maxHeartbeats`.
That is the third time in this campaign that a wrong statement has presented itself as a performance
problem, and it is now the standing rule: **a timeout is evidence about the statement first and the
machine second.**

**Brief errors**: the three window commutators are false (only the defect combination is covariant);
"defect commutes" is *equivalent* to (8.4.23) at the shifted index rather than easier than it; the
"suggested state half" (`lMinusOneCreationMode_noOrth`) is **not** the `deriv` half, since
`deriv Y m (αw) = α(deriv Y m w)` would need `Y_{m+1}` to commute with `α`, which is false.  API traps
recorded: there is no `LinearMap.map_zsmul` (use the generic `map_zsmul`) and no
`Module.End.sub_apply` (use `LinearMap.sub_apply`); plain `simp` does not close `−(c•w) = (−c)•w`;
`Finset.sum_congr` must be applied with `apply` (a `refine … fun i hi => ?_` leaves an
`AddCommMonoid ?m` stuck); and `smul_smul` merges rather than splits in this pin.

**J1 ACCEPTED — `Definitions/MMFLM810JacobiFull.lean`** (502 lines, namespace `MM.FLM810JF2`, 12
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  It was dispatched, on the owner's instruction, to take
Jacobi **in full by the book**; it came back with a **refutation of the boundary's `hjac` as stated** and
the structural reason — which is worth more than the proof would have been.

**HEADLINE: `hjac` is FALSE at an admissible datum.**

    not_jacobiOnStateTargets_ZAligned_trivialCocycle :
      ¬ JacobiOnStateTargets (F := ℚ) basisUnitInt formR (vertexOpOfField (Yaligned … extR))
    not_jacobiAxiom_ZAligned_trivialCocycle :  -- the same, in the `JacobiAxiom` spelling

i.e. **verbatim the boundary's second open input**, at `(ℚ, ℤ, Unit, trivial cocycle, ⟨m,n⟩ = mn)`.  The
theorem's hypotheses do not exclude that datum: `hs` is `mul_comm` and `hpd` holds there (the agent had to
*prove* `positiveDefinite_formR` to say so), and `E` is unconstrained data.  **So "prove 8.10.3/8.10.4/
8.10.5 for `Yaligned E`" is impossible in general** — which is exactly why FLM states (8.6.1) and Theorem
8.6.1 under the cocycle condition `c(a,b) = (−1)^{⟨a,b⟩}`, the same hypothesis batch 156's task T2 had
already isolated from the other side.

**The structural form, and it is the acceptance criterion for any future `hjac` task.**

    cocycleCompatible_of_jacobiOnStateTargets :
      JacobiOnStateTargets … E → 0 ≤ ⟨a,b⟩ → (YFam E a m * YFam E b n) (stateOfVL D) ≠ 0
        → E.c b a * (-1)^⟨a,b⟩ = 1

**The boundary's own input *implies* the (7.2.22) cocycle compatibility it does not assume.**  So the repair
is to **fix the cocycle** — `CocycleCompatible … E`, or `E := C.toCentralExtension h2` for
`C : MM.FLMLattice.EvenCocycle` — before any further Jacobi work.

**A correction to this campaign's own brief, and it is the third time a brief called a `Prop` a theorem.**
`MM.FLM810Rat.Proposition8107` (`Definitions/MMFLM810Rationality.lean:218`) is a **`def … : Prop`** — its
docstring says *"Stated, not proved"* and its TODO ledger is at `:295` — **not** the landed implication this
batch's brief asserted.  So FLM's §8.10 route has **four** inputs (8.10.3, 8.10.4, 8.10.5 **and** the 8.10.7
assembly), not three, and none of them is landed.

**Also landed, for the corrected route**: `RationalityLayer S Y` (the three propositions at one field, as a
single `Prop`); `jacobiAxiom_of_rationalityLayer` (the reduction with 8.10.7 carried as a hypothesis);
`CocycleCompatible` with `cocycleCompatible_evenCocycle`; the unconditional `0 ≤ ⟨a,b⟩` corner **at a
compatible cocycle** (`corollary851_ZAligned_lattice_of_compatible`); and the exact residual
`JacobiResidualAligned S` with `jacobiAxiom_aligned_evenCocycle_of_residual`.  A **new producer for
`Corollary851`** is landed too — `corollary851_of_faithfulJacobi_lattice`, which the reconnaissance had
recorded as having **none** anywhere in the repository; the mechanism is that producer plus the landed
`not_YFamOnGenerators_and_corollary851_rankOne`.

**`Definitions/MMFLM810BridgeProduct.lean:37`--`:50` still holds verbatim**: the `ι`-image existence half is
**not provable from repository data** (`prodCoef` comes from an arbitrary `VertexOp`; no bridge from the
component layer to `ι₁₂`'s image is landed).  What it would need is the `Res_{z₀}` argument producing the
`f` of shape (8.10.51) — i.e. (8.10.8) itself, or an independent rationality input.

**Brief errors**: `Proposition8107` is not a theorem; "the whole of Jacobi reduces to 8.10.3/8.10.4/8.10.5"
is false at arbitrary `E` (refuted above); the named blocker (`BridgeProduct`) is real but not the
operative one at the boundary as stated; the brief missed the then-uncommitted sibling file
`MMFLM810JacobiZeroFace.lean` (the agent re-proved its three small dictionary lemmas locally so that its
file depends only on committed modules); and `MM.FLM810ZMU.Yaligned` names a file that does not exist
(`Yaligned` is `MM.FLM85BA.Yaligned`, `Definitions/MMFLM85BaseFieldAligned.lean:290`, and `Yzero` lives in
`MMFLM810ZeroModeL0Uncond.lean`).

**C2 ACCEPTED — `Definitions/MMFLM810CurrentFieldComm.lean`** (476 lines, namespace `MM.FLM810CFC`, 9
guards; verified by the dispatcher: rebuild from a deleted `.olean` `--- OK ---`, token check at zero,
`FinalCheck.lean` acceptance build `--- OK ---`).  **THE TRANSLATION FIELD OF THEOREM 8.10.2 IS CLOSED.**
The batch estimate made before dispatch (the dispatcher's own answer to the owner's question) was
"two batches, maybe one" — it took **one**.

**The E⁺ commutator, which C1 had named as missing, and the correction.**  The dispatcher predicted it was
already landed as `MM.FLM86TN.modeVL_comm_annihExp_pos`; **that prediction was wrong** — that lemma is the
*positive-index* (annihilation) mode commuting with `E⁺`, not the creation-mode derivation.  What landed is
the real thing:

    modeVL_mul_annihExp_sub (hs) (a b) {n} (hn) (q) :
      modeVL b (−↑n) * annihExp a q − annihExp a q * modeVL b (−↑n)
        = ((form b a : ℤ) : F) • annihExp a (q + ↑n)

with family form `modeVL_annihFam_add` (`i ↦ i−n`).  The engine was the landed
`MM.FLM84CT.expField_comm_of_delta` (the abstract derivation property), cited rather than reproved.

**The convolution step**: `convWith_modeVL_add … : modeVL b (−↑n) ((A⊛B) m v) = (A⊛B) m (modeVL b (−↑n) v)
+ c • (A⊛B) (m−↑n) v` — the (8.5.15) convolution differentiated, with `B` applied first (so the shift has
the same direction), reindexed by the landed `MM.FLM85CP.sum_image_shift_eq` over
`T = supp(B·v) ∪ supp(B·αv) ∪ (supp(B·v)+n)`.

**The headline and the whole chain, from `hs` (7.1.1) alone**:

    currentFieldComm (hs) (E) : MM.FLM810CC.CurrentFieldComm E
    baseStateDeriv_of_currentFieldComm : BaseStateDeriv E
    creationModeStep_of_currentFieldComm : CreationModeStep E
    baseResidual_of_currentFieldComm : MM.FLM810CI.BaseResidual (baseRepaired E)
    generalStateDeriv_of_currentFieldComm (hs) : MM.FLM84LT.generalStateDeriv   -- the long-open Prop
    translationResidual_of_currentFieldComm (hnd) (hs) (E) : MM.FLM810SHC.TranslationResidual
    translationOnStateData_of_currentFieldComm
    theorem8102_of_hs : MM.FLM810TNO.theorem8102_of_generatorFieldsAligned_noOrth with `hbase` DISCHARGED

**So Theorem 8.10.2 now has exactly ONE open input: `hjac` (8.10.8)** — and that one is *refuted* in the
boundary's current form (batch 171's `not_jacobiOnStateTargets_ZAligned_trivialCocycle`), so it must first
be re-scoped to a compatible cocycle (`CocycleCompatible` / `MM.FLMLattice.EvenCocycle`) before any proof
attempt.  The remaining inputs of `theorem8102_of_hs` are data and interface hypotheses only: `hnd`, `hs`,
`E`, `S`, `hpd`, `hW`, `hfin`, plus `hjac`.

**Where the brief was incomplete, and it matters for future chains**: `derivDefect_comp_modeVL_sub` is a
*shift* law, so it does **not** by itself give `CreationModeStep`; what closes it is an induction over the
(8.5.4) creation list with the stronger hypothesis `∀ m', D(m') = 0` — base
`MM.FLM84LT.generalStateDeriv_iotaVL`, step the shift law at `m'` and `m'+n`, spanning
`MM.FLM85Un.spanningStatement`.  No `⟨b,a⟩ ≠ 0` case split is needed (`c = 0` is harmless).  The landed
`baseStateDeriv_iff_creationModeStep` cannot be reused because its IH is at fixed `m`.

**A new API trap, and it cost the batch's budget**: `Module.End F (VL F L)` carries **two
non-syntactically-equal `SMul ℚ` instances** (`LinearMap.instSMul` vs `Algebra.toSMul` of
`Module.End.instAlgebra`), so `rw [MM.FLM84CT.commutator_smul]` **fails** on the goal produced by
`MM.FLM87.annihilationExponent_apply`; it must be applied as `refine (…).trans ?_` (unification, not
matching).  Also measured: `simp only []` errors *"simp made no progress"* when there is no beta-redex;
`sub_self` does not fire on `0 − 0` at type `Module.End` (use `sub_zero`); `Finset.sum_add_distrib` must
follow the pointwise `show` rather than share the `map_sum` `rw`; and `set` for the Finset witnesses had to
become `let`.  The indexing warning did hold (`fam k = YFam (−k−1)`, `j ↦ j−n`) and was load-bearing.

### Batch 173 — the §8.10 substitution σ is CONSTRUCTED (and `SubstForm`'s reformulation is REFUTED); (8.10.73)/(8.10.46)/(8.10.72) land; the ι-bridge is measured; and **the book's Jacobi axiom is §8.8 Theorem 8.8.9, whose proof repeats Theorem 8.6.1**

Owner's directive for this session (2026-09-20): *complete Theorem 8.10.2 following the reference book*.
The dispatcher's own earlier "Route B" — hand-computing the component identity
`crossBracket = crossIterate` face by face — is **withdrawn**: it is not the book's route.  Two fresh
agents, one batch, disjoint new files; both verified here (rebuild from a deleted `.olean`,
`--- OK ---`; `Probe/forbidden_tokens.py` at zero; the `#guard_msgs` guards inside the files; and the
`FinalCheck.lean` acceptance build — see the last paragraph).

**The book's proof of the Jacobi axiom, read from the page images this session, and it corrects the
campaign's own map.**

* Printed 245: Theorem 8.10.2 is the **summary of Chapter 8** ("We have already established a number of
  axiomatic properties of vertex operator algebras ... summarized as follows").  So its (8.10.8) is what
  Chapter 8 established, namely **Theorem 8.8.9**.
* Printed 231, Theorem 8.8.9's proof, verbatim: "**We repeat the proof of Theorem 8.6.1 except for the
  following changes:** ... [Y(A,z₁) x_n Y(B,z₂)] is the coefficient of z₂^{−n−l} in (8.6.24) and the
  Theorem follows as in the earlier proof."  **Jacobi is a repeat of Theorem 8.6.1's proof**, `x_n`
  reducing the pole order (Remark 8.8.10).
* Printed 233, verbatim: "Taking Res_{z₀} leads to **an interesting alternate form of Theorem 8.6.1**:
  [Y(u,z₁),Y(v,z₂)] = Y((Y(u,z₁−z₂) − Y(u,−z₂+z₁))v, z₂). **(8.8.39)**".  So (8.8.39) — the input
  §8.10's Proposition 8.10.3 uses ("the commutator formula ... in the form (8.8.39), easily implies") —
  **is Theorem 8.6.1**, proved independently in §8.6.
* **Correction of record**: `Definitions/MMFLM810Rationality.lean:263`--`:269` says
  `ProductRationality` "needs the `Res_{z_0}` of the Jacobi identity in the form (8.8.39) — i.e. a proof
  of the Jacobi identity, which is what §8.10 is a route *to*".  That is a **circular reading**: the
  `Res_{z_0}` face is Theorem 8.6.1 and does not presuppose Jacobi.  It also explains A2's measurement
  below that the bridge is false for an arbitrary `VertexOp`: the bridge must be stated under Theorem
  8.6.1's hypothesis.
* **So the book has one engine and two continuations, not two routes**: (§8.8) repeat Theorem 8.6.1's
  proof; (§8.10) from the same Theorem 8.6.1, Props 8.10.3 → 8.10.4 → 8.10.5 → Prop 8.10.7.  Both need
  **Theorem 8.6.1 at the repaired honest field, for all states** — the single crux.

**A1 ACCEPTED — `Definitions/MMFLM810RatSubst.lean`** (375 lines against a 300-line target — reported;
namespace `MM.FLM810RSub`, 7 guards).  **The substitution σ of (8.10.66)/(8.10.67) exists**: `polySubst`
on `MvPolynomial (Fin 2) F` (`X 0 ↦ X 0+X 1`, `X 1 ↦ X 1`) and its descent
`locSubst : Loc F 2 →+* Loc F 2` by `IsLocalization.lift`, with `@[simp]` generator equations, the
uniqueness `eq_locSubst_of_fixes_constants`, and `rationalForm_locSubst` (shape (8.10.51) ↦ shape
(8.10.63): the roles of `r` and `t` interchange, the linear form becomes `z_0+z_2`).  The side
condition needed the `SSub`-generator argument (`polySubst_linForm` + `substCoefs_ne` +
`IsLocalization.map_units`), not an `F`-algebra structure.

**HEADLINE: `SubstForm` AS STATED IS TOO STRONG — `SubstForm f h ↔ h = locSubst f` is false, and so are
`Proposition8104b`/`Proposition8105` over a general field.**  `SubstForm`
(`MMFLM810RatCoef.lean:268`) quantifies over **all** ring homs σ with the two generator equations; such a
σ need not fix the constants.  For any field endomorphism φ, the φ-semilinear substitution (the lift of
`eval₂Hom` with constant map `C` followed by φ) satisfies both equations and sends `locC a` to
`locC (φ a)`; the side condition survives because φ is injective.  At `F = ℚ(x)`, `φ(x) = x²` (or
`𝔽_p(t)` and Frobenius) it differs from `locSubst`, so `SubstForm (locC x) (locSubst (locC x))`
fails.  Landed instead: `SubstFormAlg` (the constants-fixing form),
`substFormAlg_iff : SubstFormAlg f h ↔ h = locSubst f`, the unconditional half
`substForm_imp : SubstForm f h → h = locSubst f`, and `substForm_iff_iff_unique` — the brief's
equivalence for all `f,h` is **equivalent to** the uniqueness `∀σ, IsSubstHom σ → σ = locSubst`, which
is exactly what fails.  **The repair for the §8.10 statements is to restate
`Proposition8104b`/`Proposition8105` with `SubstFormAlg`**; for `F = ℚ` the two coincide (`ℚ` has no
nontrivial endomorphism), so the moonshine target is unaffected, but the general-`F` statements are
false as they stand.

**A2 ACCEPTED — `Definitions/MMFLM810ThetaKill.lean`** (250 lines, namespace `MM.FLM810TK`, 5 guards).
(8.10.73) `thetaVanishesOnZOnePoles` is landed verbatim, with the reusable
`isLaurentPolynomialMV_algebraMap_mul_laurentMonomial` and the general forms
`theta2_algebraMap_mul_laurentMonomial` (every `p·z^k`) and `theta2_algebraMap_mul_zUnit_zpow`
(`p·z_1^j`).  (8.10.46) `theta2MulMonomialStatement` **was already a theorem**
(`MMFLM810ThetaZero.lean:262`; the brief was stale) — the new content is the Laurent-polynomial
multiplier form `theta2_mul_of_isLaurentPolynomialMV`.  (8.10.72) is landed as the **existence** form
`recoverySplit_exists : ∃ Wsing Wreg, RecoverySplit Y W Wsing Wreg n`, with explicit threshold
families; **measured: the stated `RecoverySplit` needs no finiteness hypothesis** (threshold
bookkeeping), the finiteness (8.10.5) is named `IterateVanishesAbove`, and the genuinely missing datum
is `IteratePartialSumHomState` — `HomState` is homogeneous, so a finite sum of states of differing
weights has no `HomState`.

**The ι-bridge ledger, measured.**  (a) A bridge **is** landed but **vacuous**:
`MM.FLM810JB.iotaBridge_of_jacobi8108` (`MMFLM810JacobiToBridge.lean:242`) with
`jacobi8108_iff_zeroProduct` (`:130`, char 0 — the landed hypothesis `Jacobi8108` is *equivalent to*
every component product vanishing), so `prodCoef = 0` (`:201`) and `f = 0`.  (b) For an **arbitrary**
`VertexOp` the bridge is **false**: `MM.FLM810RatModel.not_productRationality`
(`MMFLM810RationalityModel.lean:231`), model computation `:203`, obstruction
`hahnSeries_coeff_bounded_above` `:66`.  (c) `ι`'s image is characterised only as a subring
(`realizableAt_iff_mem_range_iota`, `MMFLM810BridgeClosure.lean:90`, closures `:115`--`:241`); **no
support/cone characterisation**, and the only computations of `toAllPerm (ι ·)` are
`iota_laurentMonomial` (`MMFLM810ThetaZero.lean:112`) and `toAllPerm_towerMono`
(`MMFLM810Tower.lean:188`) — there is **no formula for `ι (mk' g D)`**.  (d) `MM.FLMIotaVar.lean` is a
**separate carrier** (`FLMLoc.LocRing`/`AllSeriesN` vs `Loc`/`Tower`), with no lemma linking it to
`MM.FLM810.iota`.  (e) `prodCoef` has exactly **one** landed computation — the counterexample (b); the
lattice `twoVarField` computations (`MMFLM84TwoVarProduct.lean:359`/`:375`/`:385`,
`MMFLM86ProductExpansion.lean:571`) are a **different object**, and there is no
`prodCoef ↔ twoVarField` dictionary.  (f) The only class reachable from landed material is the
square-zero one, landed here as `iotaBridge_of_zeroProduct` (`:216`), characteristic-free.  **All of
this is consistent with the book**: the bridge is a consequence of Theorem 8.6.1, so it cannot hold for
an arbitrary `VertexOp` and its statement must carry that hypothesis.

**Also**: `FinalCheck.lean` **did not import the §8.10 layer at all** (a grep for
`MMFLM810Rationality`/`MMFLM810RatCoef` was empty); the two new modules are now imported
(`FinalCheck.lean:411`, `:412`), so this layer enters the acceptance gate for the first time.
`Probe/` is gitignored — `Probe/briefs/B173-A1-subst.md`, `Probe/briefs/B173-A2-thetakill-bridge.md`
and `Probe/B173_A2_BRIDGE.md` are working files, not deliverables; their content is in this entry and
in `NOTES.md` §70.

**Batch 174 (next), on the book's route**: measure and land **Theorem 8.6.1's display at the repaired
honest field `Yaligned (C.toCentralExtension h2)` for all states** — the single input both of the book's
continuations need.  Specifically: (i) what the batch-152 "one landed `Prop`" of the display is at the
repaired field, and whether it is still the gap; (ii) the (8.4.25) two-point product at the honest field
versus the creation-half `Yzero` form of `MMFLM86ExpProduct`; (iii) the `x_n`/pole-order machinery of
(8.6.17)--(8.6.24) that Theorem 8.8.9's proof repeats.  **Batch 174 (next), on the book's route**: measure and land **Theorem 8.6.1's display at the repaired
honest field `Yaligned (C.toCentralExtension h2)` for all states** — the single input both of the book's
continuations need.  Specifically: (i) what the batch-152 "one landed `Prop`" of the display is at the
repaired field, and whether it is still the gap; (ii) the (8.4.25) two-point product at the honest field
versus the creation-half `Yzero` form of `MMFLM86ExpProduct`; (iii) the `x_n`/pole-order machinery of
(8.6.17)--(8.6.24) that Theorem 8.8.9's proof repeats.  Dispatcher estimate: 4--8 batches for Theorem
8.6.1, 2--4 more for Jacobi via §8.8, 1--2 for the assembly.

---

### Batch 174 — (8.6.3) at the boundary field IS Corollary 8.5.1 at the (8.6.2) states; the honest-field (8.4.25) engine was ALREADY LANDED and is now reindexed to `Yaligned`; and the old-field obstruction does not bite

Two fresh agents, disjoint new files, one batch; both verified here (rebuild from a deleted `.olean`,
`--- OK ---`; `Probe/forbidden_tokens.py` at zero; the in-file `#guard_msgs`; the `FinalCheck.lean`
acceptance build after wiring both in).

**B174-A ACCEPTED — `Definitions/MMFLM810Theorem861Aligned.lean`** (300 lines, namespace
`MM.FLM810T861A`, 5 guards).  The **source-faithful** (8.6.3) at the boundary field, and its exact
residual.  `Source861Aligned (C) (h2) (u' v') (a b) K := Theorem861SourceStatement form
(C.toCentralExtension h2) (ZAligned E) u' v' a b K` (`ZAligned E = (vertexOpOfField (Yaligned E)).coeff`),
`Residual861Aligned := Corollary851 (ZAligned E) (stateOf u' a) (stateOf v' b) K`.

* **HEADLINE: `source861Aligned_iff_residual` — at `1 ≤ K`, the source-faithful (8.6.3) at the boundary
  field IS `Corollary851` (8.5.13) at the (8.6.2) states, both directions.**  So the whole of `hjac` is
  now one named `Prop`, and it is the display (8.5.13), not a §8.6 chain.  (`source861Aligned_iff_core`
  removes (8.6.1) entirely; `source861Aligned_of_residual` / `residual_of_source861Aligned` are the two
  directions; `display861Aligned_iff_residue`, `residue861Aligned_iff_residual` the landed readings.)
* **Discharged at this field**: (8.6.1)'s cocycle half is a *theorem* (`hypothesis861_of_evenCocycle`);
  integrality is free by type; there is **no** base/compatibility hypothesis (`Yaligned E = Yzero
  (baseAligned E)` is a definition); the grading factor is redundant here
  (`sourceResidue861_eq_unshifted`).  **Not** part of the cost: `componentTruncationAligned` — (8.6.3) has
  no finiteness conjunct — and `FaithfulJacobi`, which only *implies* (8.6.3) vectorwise
  (`source861Aligned_vectorwise`; the uniform window is not derivable from `hjac`).
* **Proved corner**: `source861Aligned_iotaVL_of_nonneg` — `u' = v' = 1`, `0 ≤ ⟨a,b⟩`, every `K ≥ 1`,
  unconditional (from `corollary851_Yaligned_lattice_of_nonneg`).
* **The old obstructions do not bite.**  `not_l0OnWeightGenerators_modelBase` and
  `not_translationOnStateData_modelBase` are stated with `hY` about `actionPrescriptionTA …
  modelBaseField`; `Yaligned E` has base `baseAligned E` and `Yaligned_ne_Yzero_modelBaseField`
  separates the fields, so that `hY` is unsatisfiable there — sharper, both refuted predicates are
  **theorems** at the aligned field.  Batch 152's "one landed `Prop`" was `JacobiOnStateTargets`, not the
  display's residual.
* **§8.6's direct route (8.6.4)--(8.6.27), re-read at the repaired field.**  The repair changes exactly one
  item: the (8.5.2) link, refuted at `modelBase` and now the theorem
  `yFamOnGenerators_vertexOpOfField_Yaligned`.  Proved source-faithful: (8.6.4), (8.6.7), (8.6.11),
  (8.6.13), (8.6.14) per monomial, (8.6.22).  Absent: (8.6.5) (multi-variable series of states; `k = 1`
  only), (8.6.23)/(8.6.24) (scalar bookkeeping only), (8.6.25)--(8.6.27).  Stated not proved: (8.6.6),
  (8.6.8)--(8.6.10) — needing the `k`-fold normal-ordered product and the **shifted field
  `Y(a,z+w)`** — (8.6.12)/(8.6.15)/(8.6.17), and (8.6.20)/(8.6.21) whose commutator side *is* (8.6.3)'s
  extraction.  Legacy proxies: (8.6.16), (8.6.18), (8.6.19).  **So FLM's §8.6 route is blocked by three
  missing objects — the multi-variable series of states, the shifted field `Y(a,z+w)`, and the
  `k`-fold normal-ordered product — and this batch bypasses it via Remark 8.8.11**, leaving (8.5.13) at
  the (8.6.2) states as the residual.  Remark 8.3.9's spanning is still not landed.

**B174-B ACCEPTED — `Definitions/MMFLM86ExpProductAligned.lean`** (300 lines, namespace `MM.FLM86EPA`,
7 guards).  The honest-field (8.4.25) two-point product at the lattice states.

* **The P1 deficit is closed definitionally, not by new mathematics**: `Yaligned E (ι(a)) m = YFam E a
  (−m−1)` (`Yaligned_iotaVL_apply`), and `normOrdered2 = creationPair2 ⊛ midBlock2 (ab z₁^∂z₂^∂) ⊛
  annihPair2` — so the grading shift and the annihilation half that B153-P1's `Yzero (modelBaseField …)`
  lacked are simply there; the fix is the reindexing `−(−m−1)−1 = m`.
* Landed at `Yaligned E`: `Yaligned_mul_Yaligned`; `Yaligned_mul_eq_sum_ratioCoeff` (`0 ≤ ⟨a,b⟩`: the
  convolution with the contraction series `ratioCoeff`), `Yaligned_mul_iotaVL_eq_sum` (at `ι(c)`),
  `Yaligned_mul_eq_threshold` (sign-unconditional per-state threshold, from `MM.FLM86RX.threshold_holds`),
  `Yaligned_mul_eq_normOrdered2`; `Yaligned_iotaVL_apply_iotaVL` ((8.5.11)); `commutatorFamily_Yaligned`
  and `commutatorFamily_Yaligned_eq_smul` (`0 ≤ ⟨a,b⟩`: `(1 − c(b,a)(−1)^{⟨a,b⟩}) • product`) and
  `commutatorFamily_Yaligned_eq_zero` (`CocycleCompatible`).
* **The honest-field engine was ALREADY LANDED** — `MMFLM86YFamProduct` (B154-Q1) and `MMFLM86CommIota`
  (B156-T2) — and this file reindexes it; nothing was reproved.  The brief's premise "this task redoes the
  P1 engine" was stale.
* **New named residual `ResidueNegativeAligned (E) := ∀ a b, form a b < 0 → Corollary851 (ZAligned E)
  (ι a) (ι b) ((−(form a b)).toNat)`**, with `residueNegativeAligned_iff_carrier` both directions.
* Remains: (i) `⟨a,b⟩ < 0` has only the per-state threshold form, the operator-level carrier form being
  **refuted** (`not_prodExpTwoVarEnd_rankOne`, `not_locallyFinite2_contrFam_of_neg`); (ii) the outer
  evaluation `YFam E a m (creationExpVL b j (anchorVL E b c))` at Fock descendants is evaluated nowhere
  (B154-Q1 residual (i)); (iii) the Fock half for general `u, v`; (iv) `ResidueNegativeAligned`.

**Where Theorem 8.10.2 now stands.**  Everything left of `hjac` is **`Corollary851 (ZAligned E)
(stateOf u' a) (stateOf v' b) K` for all Fock `u', v' ∈ M(1)`, all `a, b ∈ L`, all windows `K`** (A's
equivalence), plus the boundary restatement at the even cocycle — the old `theorem8102_of_hs` carries `E`
free and is refuted there (`not_jacobiOnStateTargets_ZAligned_trivialCocycle`).  **Batch 175** attacks the
two open halves on disjoint files: **(A)** the Fock half at `0 ≤ ⟨a,b⟩` (arbitrary `u'`, extending
`corollary851_Yaligned_lattice_of_nonneg`; the creation-list induction of batch 172's C2 is the model),
**(B)** the negative-pairing lattice case `ResidueNegativeAligned` (a carrier question: the finite-support
**Where Theorem 8.10.2 now stands.**  Everything left of `hjac` is **`Corollary851 (ZAligned E)
(stateOf u' a) (stateOf v' b) K` for all Fock `u', v' ∈ M(1)`, all `a, b ∈ L`, all windows `K`** (A's
equivalence), plus the boundary restatement at the even cocycle — the old `theorem8102_of_hs` carries `E`
free and is refuted there (`not_jacobiOnStateTargets_ZAligned_trivialCocycle`).  **Batch 175** attacks the
two open halves on disjoint files: **(A)** the Fock half at `0 ≤ ⟨a,b⟩` (arbitrary `u'`, extending
`corollary851_Yaligned_lattice_of_nonneg`; the creation-list induction of batch 172's C2 is the model),
**(B)** the negative-pairing lattice case `ResidueNegativeAligned` (a carrier question: the finite-support
carrier cannot express `contrFam N` for `N < 0`, measured in `not_locallyFinite2_contrFam_of_neg`).

---

### Batch 175 — the Fock half reduces to the Fock MONOMIAL BASIS (and the book's (8.5.13) is the lattice case only); the negative pairing splits into `= −1` and `≤ −2`; and the carrier is NOT the wall — `NegativeChamberExpansion` is

Two fresh agents, disjoint new files, one batch; both verified here (rebuild from a deleted `.olean`,
`--- OK ---`; `Probe/forbidden_tokens.py` at zero; the in-file `#guard_msgs`; the `FinalCheck.lean`
acceptance build after wiring both in).

**B175-A ACCEPTED — `Definitions/MMFLM85CorollaryFock.lean`** (347 lines against a 300-line target,
reported; namespace `MM.FLM85Fock`, 3 guards).  The Fock half of (8.5.13) at the boundary field.

* **The book's quantification, read off the page images**: p. 195 Theorem 8.4.2 is for `a, b ∈ L̂`; p. 200
  Corollary 8.5.1, verbatim, "In the notation of Theorem 8.4.2, `[Y(a,z₁),Y(b,z₂)] = Res_{z₀}
  z₂^{−1}Y(Y(a,z₀)ι(b),z₂)e^{−z₀(∂/∂z₁)}δ(z₁/z₂)` (8.5.13)" — **it has no quantification of its own, so
  (8.5.13) is the lattice states only**.  General `u, v ∈ V_L` is Theorem 8.6.1.  **So
  `MM.FLM85Co.Corollary851` at arbitrary `a b : V_L` is strictly stronger than the book's (8.5.13)** — it
  is Theorem 8.6.1's content, which is exactly why the Fock half cannot be read off Corollary 8.5.1.
* Landed: both sides are `F`-linear in each state (`commutatorFamily_add_left`/`_smul_left`/`_add_right`/
  `_smul_right`, `corollary851Residue_*`, `corollary851_*`); the spanning reductions
  `corollary851_of_mem_span`, `corollary851_of_spanning`; `corollary851_iff_spanningStates` (with the
  landed `spanningStatement`); and **the exact reduction of the Fock half**
  `corollary851_stateOf_basis` / `residual861Aligned_fockBasis_iff`: the Fock half is *equivalent* to
  `Corollary851` at the **Fock monomial basis** `stateOf (fockMonomialBasis bL d) a`,
  `d : ModeBasisIndex κ →₀ ℕ`.  `corollary851_vl_iff_residual861Aligned` shows the whole-`V_L` statement
  is equivalent to the Fock-half residual, so working at (8.6.2) loses nothing.
* **Not landed, and the reason**: no law computes `Corollary851` at `b_i(−n)·x` from `x`; FLM (8.5.5)
  coefficientwise at `u = a(−n)x` is nowhere landed; and the created-state evaluation
  `Y ((Y (stateOf u' a)) k (stateOf v' b)) j` — which the residue itself contains — is computed nowhere.
  The missing engine already exists as unproved Props: `MM.FLM86SF.Display8610One`/`Display8610List`
  ((8.6.10), the shifted field), `MM.FLM85IS.IterateProductStepAt`/`IterateProductStepOnCreated`, and
  `MM.FLM85Co.ProductExpansion` = `MM.FLM85Ext.iterateStatement` ((8.5.12)).  B174-B computes a product
  at `ι(c)`, not the field of a created state.  **The mixed case `u' = 1`, `v'` arbitrary is not free
  either** — do not dispatch it as if it were.

**B175-B ACCEPTED — `Definitions/MMFLM86ResidueNegative.lean`** (297 lines, namespace `MM.FLM86RN`,
7 guards).  The negative-pairing case at the lattice pair, split and measured.

* **The book's own production of the negative-pairing terms** is Corollary 8.4.4 (8.4.39) (p. 196), the
  coefficient of `z_0^{−⟨a,b⟩−1}` in (8.4.38): `z_2^{−1}Σ_{k+l=−⟨a,b⟩−1} 8p_k(…)Y(ab,z_2)8
  (−1)^l(1/l!)(∂/∂z₁)^lδ(z₁/z₂)` — finite, exactly `N = −⟨a,b⟩` terms — with the verbatim case list
  (8.4.41) `≥ 0 ⇒ 0`, (8.4.42) `= −1`, (8.4.43) `= −2` (two terms), `N` terms at `−N`.
* Landed at `ZAligned E` with the (8.5.2) conjunct discharged: `residueNegative_canonical` (the exact
  (8.5.26) sum), `residueNegative_summand_shape` (the `i`-th state is the created state
  `creationExpVL a ((N:ℤ)−1−i) (anchorVL E a b)`), `residueNegative_lower_pos` (positive degree for
  `i+1 < N`), `residueNegative_top_summand` (the `i = N−1` summand closed as `ε(a,b)·YFam E (a+b) (…)`),
  `residueNegative_split`; `residue_negOne` and `negOne_iff_commutator` (the `⟨a,b⟩ = −1` case is
  *equivalent* to the honest commutator (8.4.42) at `YFam`); and
  `residueNegativeAligned_iff_negOne_and_below : ResidueNegativeAligned ↔ NegOneResidualAligned ∧
  NegTwoAndBelowResidualAligned`.
* **Correction of record — the campaign's recorded obstruction was too strong**: `negContraction_tail`
  proves `∃K, ∀k ≥ K, normOrdered2 E a b (P+k−⟨a,b⟩) (Q−k) v = 0` for **every vector** (from the landed
  `normOrdered2_locallyFinite2OneSided`), so **the finite-support carrier is not the wall**.  What the
  negative chamber needs is the (8.4.26)/(8.4.27) **two-chamber identity**, now named
  `NegativeChamberExpansion (E)` (a `def … : Prop`, consumers recorded), whose finiteness half is already
  a theorem and whose scalar split is landed (`MM.FLM87.expansionA_sub_expansionB_of_neg`).
* **Correction**: the `≤ −2` gap is **not** (8.6.10)/`Display8610List` — that display needs a product
  `mul : CoefFamily → CoefFamily → CoefFamily` the carrier does not have (which is why `mul` is a parameter
  there) — but the two-point (8.5.12) `:Y(a,z₂+w)Y(b,z₂): w^{⟨a,b⟩}` at negative `w`-powers.  And
  `YFamOnGenerators` being a theorem does **not** make `⟨a,b⟩ = −1` unconditional: the remaining conjunct
  is `h851` itself, i.e. (8.4.42).

**Where Theorem 8.10.2 now stands, and batch 176.**  Everything left of `hjac` is `Corollary851
(ZAligned E) u v K` for all `u, v ∈ V_L` (equivalently at the Fock monomial basis, B175-A), plus the
boundary restatement at the even cocycle.  Both halves converge on **one missing engine: the field at a
created state** — FLM (8.5.5) coefficientwise at `Yaligned E`, equivalently the shifted field (8.6.10)
`Y(Y(a,w)ι(1),z) = Y(a,z+w)`, whose named Props exist unproved.  **Batch 176**: (A) the (8.5.5)
coefficientwise normal-ordered formula for `Y(u,z)` at `Yaligned E` (the Fock path's engine; landed
starting points `Yzero_spec`/`Yzero_unique`, `generalVertexOperator_existsUnique`); (B)
`NegativeChamberExpansion` (the negative path's engine).  Dispatcher estimate: 2--4 batches for (A),
1--3 for (B).

---

### Batch 176 — `NegativeChamberExpansion` is a THEOREM in 11 lines (the wall moves to the Θ-collapse); (8.5.5) coefficientwise and the vacuum field of (8.6.10) are landed; and **`BaseResidual` is already a theorem at that base, so the `j = 1` level of (8.6.10) is unconditional**

Two fresh agents, disjoint new files, one batch; all four files verified here (rebuild from deleted
`.olean`s, `--- OK ---` for each; `Probe/forbidden_tokens.py` at zero; the in-file `#guard_msgs`; the
`FinalCheck.lean` acceptance build after wiring them in).

**B176-B ACCEPTED — `Definitions/MMFLM86NegativeChamber.lean`** (299 lines, namespace `MM.FLM86NC`,
7 guards).

* **(8.4.26)/(8.4.27), verbatim off the page images** (printed 192--193 = PDF 246--247):
  `[Y(a,z1),Y(b,z2)] = 1Y(a,z1)Y(b,z2)1 z1^{⟨a,b⟩}(1 − z2/z1)^{⟨a,b⟩} − (−z2/z1)^{⟨a,b⟩}(1 − z1/z2)^{⟨a,b⟩}1
  = −1Y(a,z1)Y(b,z2)1 (−z2)^{⟨a,b⟩} Θ_{z1/z2}((1 − z1/z2)^{⟨a,b⟩})` (8.4.26), and
  `Θ((1 − z)^{⟨a,b⟩}) = 0` for `⟨a,b⟩ ≥ 0`, `= (1/N!)δ^{(N)}(z)` for `⟨a,b⟩ < 0`, `N = −⟨a,b⟩ − 1`
  (8.4.27)/(8.4.28).  (The dispatcher re-checked the folio: PDF 246 → printed 192, 249 → 195, 254 → 200,
  259 → 205, so **the offset is −54**; B176-B's "−55" is wrong, and `MMFLM86SpineGap.lean`'s −54 stands.)
* **`negativeChamberExpansion : NegativeChamberExpansion E` IS A THEOREM** — batch 175's named `def`,
  verbatim, witness `Finset.range (max T0 K + 1)`, **11 lines**.  The reason it was cheap: the equality
  was *already landed* for **every** pairing as `MM.FLM86RX.threshold_holds`
  (`MMFLM86Reindex8612.lean:880`), and the finiteness was already `MM.FLM86RN.negContraction_tail`.
  `positiveChamberExpansion` is the re-indexing `P = −m−1, Q = −n−1` of the landed
  `MM.FLM86YP.YFam_mul_apply_eq_sum_ratioCoeff`.
* **The wall moves to the collapse.**  `NegOneResidualAligned` does **not** follow from the chamber
  expansion: the landed equivalence chain is
  `negOneResidualAligned_iff_chamberCollapse` and `negOneChamberCollapse_iff_blockCollapse`, with
  `NegOneBlockCollapse` the **pure-block telescoping residual** (the (8.4.27)
  `Θ((1−z)^{−1}) = δ(z)` step read on the antidiagonal `P+Q+1`), and
  `negTwoAndBelow_iff_chamberResidue : NegTwoAndBelowResidualAligned ↔ NegTwoChamberResidueIdentity`
  (whose right-hand side keeps the `ZAligned`-at-created-states summands — the same gap as B176-A's).
  Engine landed: `negChamberCommutator_eq_sum_ratioCoeff_of_window`.

**B176-A ACCEPTED — `Definitions/MMFLM85PrescriptionCoeff.lean` (244 lines) and
`MMFLM85PrescriptionCoeffLevel.lean` (247 lines)** (namespace `MM.FLM85PC`, 8 + 8 guards).

* **(8.5.5), verbatim off printed p. 198 (PDF 252)**: `Y(v,z) = Y_Z(v,z) = ⟨(1/(n₁−1)!)(d/dz)^{n₁−1}α₁(z) …
  (1/(n_k−1)!)(d/dz)^{n_k−1}α_k(z) Y(a,z)⟩` for `v = α₁(−n₁)…α_k(−n_k)·ι(a)` (8.5.4), "the normal ordered
  product being defined in an obvious way extending the rules already given"; (8.6.10) on printed p. 207.
* **(8.5.5) coefficientwise** is landed at `ZAligned E`: `ZAligned_spec` (general (8.5.4) state),
  `ZAligned_spec_cons` (the list with one more factor, unfolded as the (8.4.16) `headOp` + `tailOp`),
  `ZAligned_creationStep` (arbitrary vector `w ∈ V_L`).  **Honest note: this was already landed at an
  arbitrary base** (`MM.FLM810CI.Yzero_modeVL_eq_actionFamily`, `…_nat`,
  `actionPrescriptionTAZero_cons`, `MMFLM810CreationIntertwine.lean:205`--`:249`); these are the
  `ZAligned`/(8.5.15)-indexed transports — do not re-prove them.
* **`vacuumFieldAt_ZAligned : VacuumFieldAt (ZAligned E) vacuumVL` is a THEOREM** (from
  `Yaligned_vacuum`).  Consequence: at the honest field `Display8610List`/`Display8610One` follow from
  the **single** input `IterateProductStep (ZAligned E) conv`
  (`display8610List_ZAligned_of_step`, `display8610One_ZAligned_of_step`), which is *equivalent* to the
  landed `MM.FLM85IS.CreatedStepResidual` (`createdStep_ZAligned_iff`), and at `k = 1` is the landed
  (8.5.12) `MM.FLM85Ext.iterateStatement` (`display8610One_ZAligned_iff_iterateStatement`).  **The two
  named gaps of batches 119/121 are one at the honest field.**
* **The levels of (8.6.10) at `ZAligned`**: `j = 0` is a **theorem**
  (`display8610One_zero_level_ZAligned`); `j = 1` is **equivalent** to
  `MM.FLM810CI.BaseResidual (baseAligned E)` (`display8610One_one_level_iff_baseResidual`, both
  directions) and is proved at the lattice generators (`display8610One_one_level_iotaVL`);
  `j ≥ 2` untouched.
* **The uniqueness route does NOT work for (8.6.10)** — `Yzero_unique` compares linear maps
  `V_L → (End V_L){z}`, while `Display8610One` is about the field at one state; neither side of (8.6.10)
  is a state-linear prescription-satisfying field.  What spanning/uniqueness does give is (8.5.5) at an
  arbitrary vector, which is the landed `MM.FLM810CI` content above.

**THE DISPATCHER'S FINDING, and it is a free theorem.**
`MM.FLM810TNO.baseRepaired_eq_baseAligned` (`MMFLM810TheoremNoOrth.lean:97`) proves
`baseRepaired E = baseAligned E`, and batch 172 landed
`MM.FLM810CFC.baseResidual_of_currentFieldComm : BaseResidual (baseRepaired E)`
(`MMFLM810CurrentFieldComm.lean:392`).  **So `BaseResidual (baseAligned E)` is already a theorem**, and
B176-A's equivalence therefore makes the `j = 1` level of (8.6.10) at `ZAligned E` **unconditional** —
neither B176-A nor B176-B noticed this (B176-A calls `BaseResidual` "the open
`MM.FLM810CI.BaseResidual`").  Batch 177-A lands that corollary first and then attacks `j ≥ 2`.

**Where Theorem 8.10.2 stands, and batch 177.**  `hjac` = `Corollary851 (ZAligned E) u v K` for all
`u, v ∈ V_L`; the two named residuals are now `MM.FLM85IS.CreatedStepResidual` (the one-step (8.4.25) at
created states — B176-A's, whose `j ≤ 1` levels are unconditional and whose `j ≥ 2` levels are open) and
`MM.FLM86NC.NegOneBlockCollapse` plus `NegTwoChamberResidueIdentity` (B176-B's).  **Batch 177**: (A) land
the unconditional `j = 1` slice from `baseResidual_of_currentFieldComm` +
`baseRepaired_eq_baseAligned`, then attack `j ≥ 2` of the one-step; (B) prove `NegOneBlockCollapse` by
telescoping `normOrdered2` along the antidiagonal via its three-factor form
(`MMFLM86TwoVarNorm.lean:528`) and `MM.FLM86TN.normOrdered2_swap`, with the landed scalar shadow
**Batch 177**: (A) land
the unconditional `j = 1` slice from `baseResidual_of_currentFieldComm` +
`baseRepaired_eq_baseAligned`, then attack `j ≥ 2` of the one-step; (B) prove `NegOneBlockCollapse` by
telescoping `normOrdered2` along the antidiagonal via its three-factor form
(`MMFLM86TwoVarNorm.lean:528`) and `MM.FLM86TN.normOrdered2_swap`, with the landed scalar shadow
`MM.FLM87.expansionA_sub_expansionB_of_neg` (`MMFLMY87.lean:910`).

---

### Batch 177 — the `k = 1` case of (8.6.10) is a FREE theorem from (8.5.23)+(8.10.13) (the tower collapses to level 1); and `NegOneBlockCollapse` is REFUTED as stated — it needs the source cocycle, and the wall is the `c`-free antidiagonal collapse

Four new files, two fresh agents, one batch; all verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B177-A ACCEPTED — `Definitions/MMFLM85LevelShift.lean` (190 lines) and
`Definitions/MMFLM85PrescriptionCoeffLevel2.lean` (241 lines)** (namespaces `MM.FLM85LS` / `MM.FLM85PC2`;
15 guards, 14 at `[propext, Classical.choice, Quot.sound]` and `creationCoeff_lminusOne` at the strictly
smaller `[propext, Quot.sound]`, recorded truthfully).

* **Item 1, the free theorem**: `baseResidual_baseAligned_of_symm (hs) (E) : BaseResidual (baseAligned E)`
  (from `baseRepaired_eq_baseAligned` + batch 172's `baseResidual_of_currentFieldComm`), hence
  `display8610One_one_level_ZAligned` (the `j = 1` slice, at every lattice generator and every `n`), the
  family/all-`a` forms, `one_level_ZAligned_iff_baseResidual` (both directions) and
  `display8610List_one_level_ZAligned`.
* **HEADLINE: the `k = 1` case of (8.6.10) is no longer a gap.**  The `L(-1)`/`deriv` induction works,
  but with the **base-shifted** recurrence:
  `creationCoeff_lminusOne : state_j(L(-1)v) = (j+1)·state_{j+1}(v)` (a pure reindexing of (8.10.13)),
  `levelAt_succ_iff_levelAt_lminusOne : LevelAt Y vac v (j+1) ↔ LevelAt Y vac (L(-1)v) j` (**both**
  directions), `levelAt_succ_iterate_iff_levelAt_one`, and the creation property (8.5.23) at level 0.
  Hence `display8610One_of_creation_translation : CreationProperty Y vac → TranslationAxiom Y om →
  Display8610One Y.coeff a vac` — **(8.5.23) + (8.10.13) ⟹ (8.6.10) at `k = 1`, with no Jacobi, no
  (8.4.25), no base residual and no uniqueness argument**; `Yzero_unique` was measured *not* to apply.
  The other recurrence `L(-1)·state_j = (j+1)state_{j+1}` is neither landed nor needed.
* At the boundary field (only `hnd`, `hs`): `display8610One_ZAligned`, `levelAt_ZAligned`,
  `iterateStatement_ZAligned` ((8.5.12) at `b = ι(1)`) and `iterateProductStepAt_vacuum_ZAligned` —
  **the vacuum half of `IterateProductStep` is a theorem**.
* **New exact residual**: `def NonvacuumCreatedStep (E) : Prop := ∀ l : List (VL F L × ℕ), l ≠ [] →
  IterateProductStepAt (ZAligned E) conv (iteratedCreation (ZAligned E) vacuumVL l)`, with
  `createdStepResidual_ZAligned_iff_nonvacuumStep` and `display8610List_ZAligned_iff_nonvacuumStep`
  (both directions).  So §8.6's Fock residual is now the one-step (8.4.25) at **non-vacuum** created
  states (equivalently `k ≥ 2` of (8.6.10)); `IterateProductStep` at an arbitrary `v` stays open.

**B177-B ACCEPTED — `Definitions/MMFLM86NegOneCollapse.lean` (258 lines) and
`MMFLM86NegOneCollapseDiag.lean` (248 lines)** (namespace `MM.FLM86NOC`, 8 guards, all exactly the
three-axiom set).

* **HEADLINE: batch 176's `NegOneBlockCollapse` IS REFUTED AS STATED** — it is missing the source's
  (8.6.1) cocycle hypothesis.  The verbatim obstruction:
  `negOneBlockCollapse_eps_add_smul_eq_zero (h : NegOneBlockCollapse E) (hp : form a b = −1)
  (hq : form b a = −1) : (E.eps a b + E.eps b a) • YFam E (a+b) (m+n) v = 0` — the residual's instances
  at `(a,b,m,n)` and `(b,a,n,m)` are the *same two window sums* read as `S−T = ε(a,b)Y` and
  `T−S = ε(b,a)Y`.  Hence `(1 + E.c b a) • YFam E (a+b) N v = 0`, and at `a = b` (where `c a a = 1`)
  `YFam E (2a) ≡ 0`.  `not_negOneBlockCollapse_rankOne` (with
  `not_negOneChamberCollapse_rankOne`, `not_negOneResidualAligned_rankOne`) exhibits the failure at the
  landed rank-one datum `formR m n = mn`, `E = extR`; the general obstruction applies verbatim to an
  even form (e.g. hyperbolic `ℤ²` with the trivial cocycle).  This is the campaign's sixth
  "the named residual is false as landed" case.
* **No pointwise telescoping exists**: at `⟨a,b⟩ = −1` the two chamber sums are the two **complementary
  half-lines** `p ≥ −m` and `p ≤ −m−1` of the *same* antidiagonal, in the two families related by
  `c(b,a)`.  The corrected residual is `AntidiagonalCollapse` (**`c`-free**: the two half-sums of the
  single family `normOrdered2 E a b` add up to `ε(a,b)·YFam E (a+b)(m+n)`), and the main equivalence is
  `negOneBlockCollapse_iff_antidiagonalCollapse (hs) (E) (hc : NegOneSourceCocycle E)` — **both
  directions**.  `NegOneSourceCocycle` is exactly the source's (8.6.1) at `⟨a,b⟩ = −1`, and it **holds at
  the boundary field**: `CocycleCompatible` gives `c(b,a)·(−1)^{−1} = 1`, i.e. `c(b,a) = −1`.  What is
  left is the assembly identity `(:YY:_{ab})(z,z) = ε(a,b)·Y(a+b,z)` (creation exponentials add,
  annihilation adds, the middle block gives `ε(a,b)(a+b)z^{(a+b)(0)}`), stated not proved.
* **`≤ −2`**: untouched beyond its statement; its summands are `ZAligned` at the (8.5.11) created states,
  i.e. exactly `MM.FLM85IS.IterateProductStepOnCreated`.  **The `−1` case is the first step of that
  induction and the `≤ −2` case its iterate** — so B177-A's and B177-B's residuals meet at the same
  created-state evaluation.

**Where Theorem 8.10.2 stands at the end of batch 177.**  `hjac` at the boundary field is
`Corollary851 (ZAligned E) u v K` for all `u, v ∈ V_L`; its two named residuals are now
**(1)** `NonvacuumCreatedStep E` (the one-step (8.4.25) at non-vacuum created states; equivalently
`k ≥ 2` of (8.6.10)) and **(2)** `AntidiagonalCollapse` under `NegOneSourceCocycle` (whose remaining
assembly is `(:YY:_{ab})(z,z) = ε(a,b)Y(a+b,z)`), plus the `≤ −2` iterate (3) which meets (1).
**Batch 178**: (A) `NonvacuumCreatedStep` — measure whether the `(8.5.23)+(8.10.13)` structure extends
to the non-vacuum states or whether the genuine normal-ordering step is irreducible; (B)
`AntidiagonalCollapse`'s assembly identity.

**Brief errors this batch**: B177-B's task was a refutation, not a proof (the brief's requested
telescoping cannot exist); two measured API traps — `rw`/`simp` cannot rewrite under a `Finset.sum`
binder whose pattern mentions the bound variable (use `apply Finset.sum_congr rfl; intro k _`), and
`neg_one_smul` does not match `(-1 : F) • x` here (use `exact neg_one_smul F x`); and the `LMinusOneCreationMode`
machinery the brief pointed at is not used by B177-A.

**Brief errors this batch (176)**: `Definitions/MMFLM86LS.lean` does not exist (`normOrdered2_locallyFinite2OneSided`
is `MMFLM86LimitStep.lean:320`); `Definitions/MMFLM86PE*.lean` matches no file (it is
`MMFLM86ProductExpansion.lean`); `MM.FLM87.expansionA_sub_expansionB_of_neg` is in `MMFLMY87.lean`;
the display-page range in B176-A's brief was one leaf early; and `YFam_mul_eq_convWith2_contrFam` is
conditional on `0 ≤ ⟨a,b⟩` so it is not the negative-pairing route.

**Brief errors this batch**: `Definitions/MMFLM86CI.lean` does not exist (the namespace `MM.FLM86CI` is in
`MMFLM86CommIota.lean`; the `−1` lemmas are in `MMFLM86IterateIota.lean`); `Display8612`/
`OperatorDisplay` do not exist; the recorded "carrier cannot express `contrFam N`" is too strong;
`tools/build.sh` **is** usable on this box; and (8.6.3) carries `((z₁/z₂)^a δ(z₁/z₂))` with
`e^{−z₀(∂/∂z₂)}`, not the `e^{−z₀(∂/∂z₁)}δ` of (8.5.13).

**Brief errors this batch**: `YFam` is in `Definitions/MMFLM84LatticeField.lean` (not `MMFLM84LF.lean`);
the import targets `MMFLM810ZMU/TB`, `MMFLM85Co`, `MMFLM810JZF/JF2` live in
`MMFLM810ZeroModeL0Uncond.lean`, `MMFLM810TranslationBase.lean`, `MMFLM85Corollary.lean`,
`MMFLM810JacobiZeroFace.lean`, `MMFLM810JacobiFull.lean`; `twoVarField_iotaVL`,
`vacuumVL_right_eq_YCoeff`, `vacuumVL_zero` do not exist (`YFam_iotaVL`, `YFam_vacuumVL_eq_YCoeff`,
`YFam_vacuumVL` are the names); `tools/build.sh` **is** usable in this environment (its hardcoded
`FLT` exists) — the "not usable here" of `AGENTS.md` is stale for this box; and (B174-A) the brief's
inventory list `Theorem861`/`Theorem861.of_cutoff`/`theorem861Residue_*` points at legacy scalar proxies
(`MMFLM86SpineGap.lean:52`--`:61`), none of which states (8.6.3).

---

### Batch 178 — `NonvacuumCreatedStep` is REFUTED (the `conv` carrier gates on two-sided finiteness, so the whole `conv`-form §8.6 chain is false); and `AssemblyDiagonal` is the single named residual of the `⟨a,b⟩ = −1` case, whose hard step is `expField` multiplicativity

Three new files, two fresh agents, one batch; all verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B178-A ACCEPTED — `Definitions/MMFLM85NonvacuumStep.lean` (233 lines) and
`MMFLM85NonvacuumRefute.lean` (226 lines)** (namespaces `MM.FLM85NV` / `MM.FLM85NVR`; all guards exactly
the three-axiom set).

* **Reduction, hypothesis-free**: `nonvacuumCreatedStep_iff_singletonCreatedStep` — the created-state
  step at *any* state is the step at a **one-factor** created state (FLM (8.5.23) does it in one line; no
  induction on the list is needed) — and `nonvacuumCreatedStep_iff_iterateProductStep`; with `hnd`, `hs`,
  `nonvacuumCreatedStep_iff_display8610Two` and `display8610List_iff_display8610Two` (so `k = 2` implies
  every `k`).  The shortest case is `Display8610Two E`, i.e. (8.6.10) at `k = 2`.
* **HEADLINE: the short case is FALSE, and with it the whole `conv`-form §8.6 chain.**  For every
  `a ≠ 0`: `ZAligned E (ι(a)) j ι(1) ≠ 0` for all `j ≤ −1` (`ZAligned_iotaVL_vacuumVL_ne_zero`), so
  `¬ LocallyFiniteCoef (ZAligned E (ι(a)))` (`not_locallyFiniteCoef_ZAligned_iotaVL`).  `conv` is a
  `dite` on `LocallyFiniteCoef` of its **second** argument, hence `conv A (YFam E a) = 0`; the step at
  the created state `ι(a)` at `x = ι(1)`, `j = 0` demands `YFam E a = conv vacuumField (YFam E a) = 0`,
  and the left side is nonzero on the vacuum.  Landed: `not_iterateProductStepAt_ZAligned_iotaVL`,
  `not_nonvacuumCreatedStep_of_ne_zero`, `not_createdStepResidual_ZAligned`,
  `not_iterateProductStep_ZAligned`, `not_display8610List_ZAligned`, `not_display8610Two_of_ne_zero`.
* **This is a carrier defect, not FLM's mathematics**: the defect class is batch 133's (`MMFLM86IS`
  refuted the two-sided `LocallyFinite2`), and the repair must consume the **one-sided** (8.10.5)
  (`MM.FLM84LF.YFam_eq_zero_of_gt`) and/or the joint `8…8` object of (8.6.25).  The missing FLM object is
  **(8.6.6)'s third family** — the ordinary product vs the normal-ordered one, i.e. the OPE contraction
  `(z₁−z₂)^{⟨ā,b̄⟩}`, `MM.FLM86KF.Display866Family3` — **not** (8.6.5)/(8.6.9)/`kFoldNormalOrder`, which
  are landed.
* **Consequences for the ledger**: `NonvacuumCreatedStep`, `CreatedStepResidual`, `IterateProductStep`
  and `Display8610List` are all false at `ZAligned`/`conv`, so **no Jacobi-type input (hjac included)
  can prove them**; B177-A's `display8610List_ZAligned_iff_nonvacuumStep` is a valid equivalence between
  two false statements.  `hjac`/`JacobiAxiom` itself is untouched, and the `k = 1` theorem and the vacuum
  step of batch 177 stand (they do not apply `conv` to a non-locally-finite family).
* **A repo trap worth keeping**: `Definitions/MMFLM85StepLinear.lean` is imported by **nothing** yet holds
  `iterateProductStepAt_iff_apply`, which `MMFLM85IS`'s header cites as landed; without the explicit
  import the statement silently elaborates with `sorryAx` (the guards catch it).

**B178-B ACCEPTED — `Definitions/MMFLM86AntidiagonalAssembly.lean`** (331 lines against a 300-line target,
reported; namespace `MM.FLM86AA`, 3 guards plus an all-declarations check).

* **`AssemblyDiagonal (E)` is landed** (pairing-free, FLM (8.4.20) at `z₁ = z₂ = z`):
  `∀ a b m n v, ∃ s : Finset ℤ, (∀ p ∉ s, normOrdered2 E a b p (−m−n−1−p) v = 0) ∧
  diagSum (normOrdered2 E a b) s (−m−n−1) v = ε(a,b) • YFam E (a+b) (m+n) v`, i.e.
  `(:YY:_{ab})(z,z) = ε(a,b)·Y(a+b,z)` in carrier form; `NegOneAssemblyDiagonal` is its
  `⟨a,b⟩ = −1` instance.
* **Both directions**: `assemblyDiagonal_iff_collapse : NegOneAssemblyDiagonal E ↔ AntidiagonalCollapse E`
  — the reindexing of the `ℤ`-window into the two `ℕ`-half-windows, with no product, commutator or
  residue used.  Consumer map: `AssemblyDiagonal → AntidiagonalCollapse → (NegOneSourceCocycle) →
  NegOneBlockCollapse → NegOneResidualAligned`, with `negOneSourceCocycle_of_cocycleCompatible`
  (`CocycleCompatible` + `⟨a,b⟩ = −1` ⇒ `c(b,a) = −1`) and
  **`negOneResidualAligned_evenCocycle_of_assemblyDiagonal : AssemblyDiagonal (C.toCentralExtension h2) →
  NegOneResidualAligned (C.toCentralExtension h2)`** — the `−1` case now has exactly **one** named missing
  input, no cocycle or window hypothesis.
* **The exact residual is `AssemblyDiagonal`**, whose proof is the factor diagonalisation in four steps
  documented in the file's header.  **The hard step is `expField` multiplicativity**
  (`E⁻_a(z)E⁻_b(z) = E⁻_{a+b}(z)`), which is landed **nowhere** — the landed
  `MM.FLM86EP.creationExpVL_mul_comm` is *commutation*, not exponent addition.  Finiteness is not the
  wall (`MM.FLM86LS.normOrdered2_locallyFinite2OneSided` already gives the `∃ s`).
* The `≤ −2` case is untouched (`NegTwoChamberResidueIdentity`).

**Where Theorem 8.10.2 stands at the end of batch 178.**  `hjac` = `Corollary851 (ZAligned E) u v K` for
all `u, v ∈ V_L` (untouched by the refutation — it is a statement about `commutatorFamily` and the
residue, not about the `conv`-gated product).  The live residuals are **(1)** the `⟨a,b⟩ = −1` case's
`AssemblyDiagonal` (hard step: `expField` multiplicativity), **(2)** the `≤ −2` iterate, and **(3)** the
Fock half, whose route through the `conv`-form (8.6.10) is now **dead** and must be rebuilt on a one-sided
product (the (8.6.6) third-family object).  **Batch 179**: (A) `expField` multiplicativity then the four
steps of `AssemblyDiagonal`; (B) the one-sided carrier repair — define the product with one-sided
finiteness and restate (8.6.10) on it, measuring how much of batch 177's `k = 1` theorem survives.

**Brief errors this batch**: `creationExpVL_mul` does not exist (`creationExpVL_mul_comm` is commutation);
the prescribed list induction was unnecessary; the suggested per-state product tools are a dead end for the
created-state step; and the `≤ 300`-line cap forced a split.

---

### Batch 179 — the one-sided product repair is landed (the previously refuted vacuum step is now a theorem); `expField` multiplicativity is a theorem (via a NEW Leibniz rule) and 2 of `AssemblyDiagonal`'s 4 steps are done

Four new files, two fresh agents, one batch; all verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B179-A ACCEPTED — `Definitions/MMFLM86ExpFieldMul.lean` (300 lines) and `MMFLM86ExpFieldMulLat.lean`
(248 lines)** (namespace `MM.FLM86EFM`, 5 guards, all exactly the three-axiom set).

* **`expField` multiplicativity IS LANDED**: `flatMul_expField_of_commute (h : ∀ i j, Om i * Om' j =
  Om' j * Om i) : flatMul (expField Om) (expField Om') = expField (Om + Om')` over an arbitrary
  `Ring A`/`Algebra ℚ A`.  **The real missing engine was a Leibniz rule**,
  `deriv_flatMul : deriv (flatMul X Y) = flatMul (deriv X) Y + flatMul X (deriv Y)`, landed nowhere
  before (`MMFLM84Diag`/`MMFLM84Subst` record it as open); with `expField_unique`, `flatMul_assoc` and
  `flatMul_swap` the multiplicativity follows.  Exponent linearity (`exponentField_add`,
  `creationExponent_add`, `annihilationExponent_add`) is landed too.
* **Steps 1 and 3 of `AssemblyDiagonal` are landed**, in the antidiagonal forms the carrier consumes:
  `flatMul_creationExpVL` (`E⁻_aE⁻_b = E⁻_{a+b}`), `sum_creationPair2_antidiagonal`,
  `flatMul_annihExp` and `sum_annihPair2_antidiagonal` — the `E⁺` half on the **mirrored** families
  `i ↦ annihExp a (−i)` (a separate statement with a separate (7.1.5) input
  `MM.FLM86TN.modeVL_comm_of_pos`), not "the same proof".
* **Steps 2 and 4 are NOT proved, so `AssemblyDiagonal` is still a `Prop`.**  Step 2 is landed as the
  exact named residual `MiddleBlockDiagonal (E)` (the middle-block antidiagonal collapse
  `Σ_{p} midBlock2 a b p (N−p) = ε(a,b)·(a+b)z^N`, a `def … : Prop` clearly marked not proved, with its
  route recorded); its proof did not compile in three rounds (`iota` defeq and induction-motive
  normalisation), and per the budget rule the agent stopped rather than weaken it.  Step 4 (nested
  `convWith2` → `convWith`) is documented but is not a single clean identity (the inner index enters
  through the total degree).

**B179-B ACCEPTED — `Definitions/MMFLM85OneSidedProduct.lean` (281 lines) and `MMFLM85OneSidedChain.lean`
(238 lines)** (namespace `MM.FLM85OSP`, 7 guards, all exactly the three-axiom set).

* **The defect, verbatim**: `conv A B` is a `dite` on `LocallyFiniteCoef B` (a **two-sided** per-state
  window), while the honest field satisfies only the upper half (FLM (8.10.5),
  `MM.FLM84LF.YFam_eq_zero_of_gt`), so `conv A (YFam E a) = 0` — the batch-178 refutation.
* **The repair**: `PairFinite A B := ∀ m w, ∃ s, ∀ j ∉ s, A (m−1−j) (B j w) = 0` and
  `convOneSided` (total).  `convOneSided_eq_conv` proves **agreement wherever `conv` was defined**, so
  nothing landed is lost; `convOneSided_vacuumField(_left)` are **unconditional** where the landed
  `conv_vacuumField_left` needed `LocallyFiniteCoef`; `convOneSided_assoc` holds on the locally-finite
  class; `pairFinite_of_opAbove_of_above`, `pairFinite_singletonCoef_left`,
  `pairFinite_vacuumField_left/_right`.
* **The batch-178 refuted instance is now a THEOREM**:
  `vacuumShiftStep_ZAligned_convOneSided : ZAligned E ((ZAligned E vacuumVL) (−1) v) =
  convOneSided (shiftedField (ZAligned E) vacuumVL 0) (ZAligned E v)` for **every** `v`; batch 177's
  `display8610One_ZAligned`, `levelAt_ZAligned`, `iterateStatement_ZAligned` contain no `conv` and
  transport verbatim; `display8610List_convOneSided` gives (8.6.10) at every `k`.
* **New shortest residual**: `Display8610TwoOneSided` / `SingletonCreatedStepOneSided`, with
  `createdStepOneSided_iff_twoOneSided`.
* **Measurement that matters**: **two honest fields still do not form a `PairFinite` pair** (recorded, not
  asserted, as `PairFiniteHonestFields`: at `m = 2⟨a,a⟩−1` the summand has `j`-independent weight, so the
  sum is infinite).  So the general two-factor display is **not** a carrier problem — it is the OPE gap
  `MM.FLM86KF.Display866Family3` ((8.6.6)'s third family), exactly as batch 178 predicted.

**Where Theorem 8.10.2 stands at the end of batch 179.**  `hjac` = `Corollary851 (ZAligned E) u v K`
for all `u, v ∈ V_L`.  Live residuals: **(1)** `AssemblyDiagonal` — now only its steps 2
(`MiddleBlockDiagonal`) and 4; **(2)** the `≤ −2` iterate; **(3)** the Fock half, whose repaired
one-sided chain reduces to `Display8610TwoOneSided`, i.e. the OPE third family
`Display866Family3`.  **Batch 180**: (A) `MiddleBlockDiagonal` + step 4 (with the route batch 179-A
recorded: collapse on `F{L}` via `zPowH_iota` and `form a c + form b c = N`, then the tensor-factor
transfer); (B) the OPE third family `Display866Family3` — connect the general two-factor product to the
landed two-variable `normOrdered2`/`ratioCoeff` product (`MM.FLM86EPA.Yaligned_mul_eq_sum_ratioCoeff`)
and restate the `k = 2` display at the two-variable level.

---

### Batch 180 — `MiddleBlockDiagonal` (step 2 of `AssemblyDiagonal`) is LANDED; step 4 becomes the single residual `AssemblyDiagonalResidual` (pure index regrouping) with the reduction proved; and the OPE third family is corrected and bridged

Three new files, two fresh agents, one batch; all verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B180-A ACCEPTED — `Definitions/MMFLM86MiddleBlockDiag.lean` (294 lines) and
`MMFLM86MiddleBlockDiagStep4.lean` (295 lines)** (namespace `MM.FLM86MBD`; 7 guards, all exactly the
three-axiom set).

* **Step 2 IS LANDED**: `middleBlockDiagonal (E) : MM.FLM86EFM.MiddleBlockDiagonal (F := F) form E` —
  verbatim batch 179-A's def (the middle block on the antidiagonal collapses to
  `ε(a,b)·(a+b)z^N`).  Route confirmed: on `F{L}` the window is the image of the support under `form a`,
  `zPowH_iota` gives the pair condition and `form a c + form b c = form (a+b) c` turns it into the single
  eigenvalue (`midGrad_iota_diag`); then `TensorProduct.induction_on` + `zPowHVL = TensorProduct.map id`
  (`tensor_map_id_id`) + `actVL_mul_actVL`.  **The earlier failures were caused by the wrong tool**:
  `Finsupp.induction_linear` (add/single) with `Finset.sum_subset` works where extensionality did not.
* **Step 4 is reduced to ONE named `Prop`**: `diagSum_convWith2` (the total-degree reindexing of a
  `convWith2` diagonal sum, unconditional) and `diagSum_convWith2_nested` (the same for
  `(X ⊛ Y) ⊛ Z`, i.e. `normOrdered2`'s shape) and `sum_creationPair2_window` (step 1 in window form) are
  landed, and `def AssemblyDiagonalResidual (E) : Prop` states the remaining regrouping:
  `∑_{q∈w}∑_{q'∈w' q} creationExpVL (a+b) (N−q.1−q.2−q'.1−q'.2) (midBlock2 q'.1 q'.2 (annihPair2 q.1 q.2 v))
  = ε(a,b) • YFam (a+b) (−N−1) v`.  **`assemblyDiagonal_of_residual (hs) (E) : AssemblyDiagonalResidual E →
  AssemblyDiagonal E` is PROVED.**  Recipe for the next task, measured: take a **uniform** middle window
  `w' q = ⋃_{q∈w}(canonical window)` (with per-`q` windows the `K'`-ranges differ and the fibers cannot be
  combined), then group by `J = q.1+q.2` (step 3), group by `K' = q'.1+q'.2` (step 2, now a theorem), and
  read `(J,K')` as `YFam`'s `(j,i) = (−J−1,−K'−1)` via `YFam_eq_sum_three_factor`.
* So the `⟨a,b⟩ = −1` case at `ZAligned (C.toCentralExtension h2)` is unconditional **modulo
  `MM.FLM86MBD.AssemblyDiagonalResidual` alone**; the landed `assemblyDiagonal_iff_collapse` chain is
  unchanged (it consumes `AssemblyDiagonal`, which is still a `Prop`).

**B180-B ACCEPTED — `Definitions/MMFLM86OPEThird.lean`** (427 lines against a 300-line target, reported;
namespace `MM.FLM86OPE` — `MM.FLM86OT` is taken by `MMFLM86OrdTwo.lean`; 11 guards, all exactly the
three-axiom set).

* **(8.6.6) verbatim off printed p. 206** — `A = 8Y(a₁,w₁)…Y(a_k,w_k)8 ι(1) = Y(a₁,w₁)…Y(a_k,w_k)ι(1)
  ∏_{i<j}(w_i−w_j)^{−⟨ā_i,ā_j⟩}`, with the sentence above it: "…understood as the binomial expansion in
  non-negative integral powers of `w_j`".  (8.4.25) and (8.5.12) are quoted too.
* **Correction of record**: the repository's `MM.FLM86KF.Display866Family3` **is not** the landed
  two-variable product — it reads the printed *series* factor as a *scalar* `pairingFactor … w n` (true
  only at null exponents), and its type `Fin k → ℕ → VL` reads the multidegree only in its first
  coordinate, so it can never carry a `k`-variable coefficient family.  Landed instead: the corrected
  multi-index form `Display866Family3TwoIdx` with its proved null-pair instance
  `display866Family3_twoIdx_honest_nullPair`, and **`Display866Family3Two` + `display866Family3Two`
  (the printed third family at `k = 2`, unconditional for `0 ≤ ⟨a,b⟩`)**.
* **The bridge the display consumes is landed**: `shiftedField_ZAligned_apply_eq_sum_ratioCoeff` — (8.4.25)
  at the **shifted** honest fields, i.e. the `w₁^j w₂^l`-coefficient of `Y(a,z+w₁)Y(b,y,z+w₂)` equals
  `(binom …)·Σ_i ratioCoeff ⟨a,b⟩ i • normOrdered2 E a b (…+i−⟨a,b⟩) (…−i) v` — the display's right-hand
  side evaluated by the landed `normOrdered2`+`ratioCoeff` expansion.  Auxiliaries:
  `ZAligned_mul_apply_eq_sum_ratioCoeff` (batch 174 re-indexed), `ZAligned_mul_eq_normOrdered2`,
  `convOneSidedWith_eq_sum_choose`.
* The display is restated as `Display8610TwoGenerators` (its lattice-generator slice, with
  `display8610TwoGenerators_of_display` from `Display8610TwoOneSided`), the datum
  `ShiftedPairFiniteGenerators` is **recorded, not asserted**, and
  `display8610TwoGenerators_iff_ratioForm` is proved **both directions** given that datum.
* **The Fock half is not closed**: the field-of-the-created-state equation itself, the datum (or a
  carrier-free replacement), and the full display at arbitrary `x y : V_L` remain open.  The brief's
  "not a carrier problem, it is the OPE gap" was half right: the `convOneSided` form carries
  `PairFinite` (and returns 0 without it), the OPE is what evaluates the product where it holds.

**Where Theorem 8.10.2 stands at the end of batch 180.**  `hjac` = `Corollary851 (ZAligned E) u v K` for
all `u, v ∈ V_L`.  Live residuals: **(1)** `MM.FLM86MBD.AssemblyDiagonalResidual` — a pure double-sum
regrouping whose recipe is now fully measured, and which alone gives the `⟨a,b⟩ = −1` case at the even
cocycle; **(2)** the `≤ −2` iterate; **(3)** the Fock half's created-state equation (the two-factor
display), with the OPE bridge now landed.  **Batch 181**: (A) prove `AssemblyDiagonalResidual` by the
recorded regrouping (uniform middle window, group by `J` and `K'`, read via `YFam_eq_sum_three_factor`);
(B) the two-factor created-state display at the lattice-generator slice, using B180-B's bridge and the
landed (8.5.5) prescription.

---

### Batch 181 — MILESTONE: `AssemblyDiagonal` is a THEOREM (the `⟨a,b⟩ = −1` case of `hjac` is unconditional at the boundary field); and the two-factor display is refuted wherever the carrier datum fails, with `PairFinite` itself now UNDECIDED

Four new files, two fresh agents, one batch; all verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B181-A ACCEPTED — `Definitions/MMFLM86AssemblyResidualFibers.lean` (219 lines),
`MMFLM86AssemblyResidualAux.lean` (168 lines), `MMFLM86AssemblyResidual.lean` (264 lines)** (namespace
`MM.FLM86AR`, 7 guards, all exactly the three-axiom set).

* **`assemblyDiagonalResidual : AssemblyDiagonalResidual (F := F) bL form E` is proved VERBATIM**
  (batch 180-A's `def`, no weakening), with the new fiber lemmas `sum_filter_fiber_eq`,
  `sum_annihPair2_fiber` (step 3 in fiber form over **any** window), `sum_midBlock2_fiber` (step 2 fiber
  form) and the regrouping `sum_sum_window_regroup`.
* **`assemblyDiagonal (hs) (E) : AssemblyDiagonal (F := F) bL form E` — `AssemblyDiagonal` IS A THEOREM**,
  and composing with the landed `MM.FLM86AA.negOneResidualAligned_evenCocycle_of_assemblyDiagonal` gives
  **`MM.FLM86AR.negOneResidualAligned_evenCocycle`**: `NegOneResidualAligned` at
  `ZAligned (C.toCentralExtension h2)` for **every symmetric form**, no residual hypothesis.  **The
  `⟨a,b⟩ = −1` case of `hjac` is closed** (with the `0 ≤ ⟨a,b⟩` corner closed in batch 170 D1).
* **Method correction of record**: the middle window must be **one common window for all `q`** — the agent
  used the rectangle `WP ×ˢ WQ` of the projections of the per-`q` windows, **not** the brief's
  `Finset.biUnion`-of-canonical-windows (with a `q`-dependent `w' q` the `K'`-image differs per `q` and
  the fibers cannot be combined).  Also: the landed `sum_annihPair2_antidiagonal`/`middleBlockDiagonal`
  are canonical-window statements, so pinning them to the residual's arbitrary window needed the two new
  fiber lemmas; `YFam_eq_sum_three_factor` lives in `MM.FLM84TV`; and the annihilation/middle total
  degrees are `≤ 0`/any integer respectively (the brief's ranges were sign slips).

**B181-B ACCEPTED — `Definitions/MMFLM86TwoFactorDisplay.lean`** (469 lines against a 300-line target,
reported; namespace `MM.FLM86TFD`, 12 guards).

* **State dictionary and the `j = l = 0` slice are fully evaluated**: `zAligned_iotaVL_family`,
  `creationCoeff_iotaVL` (the created state is the (8.5.11) coherent state),
  `iteratedCreation_two_zero : the display's LHS state = creationExpVL a (−⟨a,b⟩) (anchorVL E a b)`,
  `iteratedCreation_two_zero_eq_anchor` at `⟨a,b⟩ = 0`, and `createdState_zero_zero_ne_zero` — the LHS
  at component `−1` on the vacuum is `ε(a,b)·ι(a+b) ≠ 0`.
* **HEADLINE, and it refutes the display on the failing datum**: `convOneSided A B = 0` definitionally
  when `¬ PairFinite A B` (`convOneSided_eq_zero`), hence `not_display8610TwoGenerators` and
  **`display8610TwoGenerators_false`**: at **any** null pair, if `PairFinite (ZAligned E (ι a))
  (ZAligned E (ι b))` fails then `Display8610TwoGenerators E` is **false**; and
  `not_display8610TwoOneSided` shows the repaired `convOneSided` carrier is **not neutral** — the display
  inherits its 0-on-failure behaviour.  So the generator slice is exactly **[carrier datum AND the (8.4.25)
  ratio form]**, not merely the LHS evaluation (`display8610TwoGenerators_iff_ratioForm` is the exact
  two-direction statement).
* **The batch-179-B reason for expecting the datum to fail is NOT a proof**: the `j`-independent-weight
  summand shows only that all summands lie in one weight space, which is infinite-dimensional and
  compatible with either behaviour.  **`PairFinite (ZAligned E (ι a)) (ZAligned E (ι b))` is UNDECIDED in
  the repository** (no proof, no refutation).  **This is the fork for the Fock half**: if it holds (on the
  needed slices), the Fock half is exactly the created-state evaluation — the (8.5.5) prescription of the
  coherent state `YFam E a (−j−1)(creationExpVL b l (ι b))`, which is **not** a (8.5.4) state for `l > 0`;
  if it fails, `Display8610TwoGenerators`/`Display8610TwoOneSided` are false and the honest replacement is
  the OPE product `Display866Family3Two` (landed for `0 ≤ ⟨a,b⟩`).
* The span reduction cannot be transported through the `dite` carrier (linearity holds with the datum
  fixed, but `convOneSided` need not be additive), so the brief's span route is blocked by the carrier,
  not by `spanningStatement`.

**Where Theorem 8.10.2 stands at the end of batch 181.**  `hjac` = `Corollary851 (ZAligned E) u v K`;
of its lattice-pair cases, `0 ≤ ⟨a,b⟩` (batch 170) and `⟨a,b⟩ = −1` (this batch) are **closed**, and the
live residuals are **(1)** the `⟨a,b⟩ ≤ −2` case (`NegTwoAndBelowResidualAligned` /
`NegTwoChamberResidueIdentity`), **(2)** the Fock half, now reduced to **deciding `PairFinite`** on the
shifted honest pairs, and **(3)** the final boundary restatement at the even cocycle.
**Batch 182**: (A) decide `PairFinite (shiftedField (ZAligned E) (ι a) j) (shiftedField (ZAligned E) (ι b) l)`
— prove it or refute it, and either way land the resulting Fock-half statement; (B) the `≤ −2` case.

**Brief errors this batch**: the `⋃_q` middle-window recipe; `YFam_eq_sum_three_factor`'s file; the two
degree-range slips; "apply the free `k = 1` theorem twice" cannot work (it needs the creation property at
the same vacuum, and the non-vacuum one-step is the missing input); "the RHS evaluation is landed" only
given the undecided datum; and route (b) cannot start for `l > 0` because the created state is not a
(8.5.4) state.

**Brief errors this batch**: step 4 did not go through (it is now one `Prop`); `Finsupp` extensionality is
not the step-2 route (`induction_linear` is); the consumer chain cannot close until `AssemblyDiagonal` is
proved; `MM.FLM86KF/EPA/TN.lean` are not file names (those namespaces live in `MMFLM86KFold.lean`,
`MMFLM86ExpProductAligned.lean`, `MMFLM86TwoVarNorm.lean`); and `Display866Family3` is a scalar
mis-reading of a series factor.

**Brief errors this batch**: the missing engine was the Leibniz rule, not `expField_unique`; the
multiplicativity needs the coefficient-level commutation hypothesis consumed in `flatMul_swap`; the
`E⁺` half is a separate statement; the folio "`−54`" vs "`−55`" is a 0-based/1-based convention
difference, not an error; and the general one-sided product gate must be on the **pair**, not on the
second argument alone.

---

### Batch 182 — `PairFinite` is PROVED on the honest pairs (the Fock fork closes in favour of the datum, and the batch-179/181 "infinite sum" recording is REFUTED); and the `⟨a,b⟩ = −2` residue is reduced to `NegTwoBlockCollapse`

Five new files, two fresh agents, one batch; all verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).  **The dispatcher also corrected five
now-false docstrings in existing files** (see the last paragraph).

**B182-A ACCEPTED — `Definitions/MMFLM85PairFiniteDecide.lean`** (340 lines against a 300-line target,
reported; namespace `MM.FLM85PFD`, 8 guards, all exactly the three-axiom set).

* **HEADLINE: `PairFinite` is PROVED, not refuted.**  Key identity
  `ZAligned_convSummand_eq_sum_ratioCoeff`: for symmetric `form` and `0 ≤ ⟨a,b⟩`,
  `(ZAligned E (ι a) (m−1−j)) ((ZAligned E (ι b) j) w) = Σ_{k ≤ ⟨a,b⟩} ratioCoeff ⟨a,b⟩ k •
  normOrdered2 a b (j−m+k−⟨a,b⟩) (−j−1−k) w` — (8.4.25) along the diagonal `(m−1−j, j)`, the two
  `normOrdered2` indices moving in **opposite** directions in `j`.  The per-state (8.10.5) bounds
  (`normOrdered2_locallyFinite2OneSided`) then confine the support to `Finset.Icc (K1+m+1) (−K2−2)`
  (shifted: `Icc (K1+m−j+1) (l−K2−2)`).  **The `j`-independence of the summand weight is compatible
  with finite support, and the support is finite** — the batch-179-B/180-B/181-B argument was not a proof
  and its conclusion was false.
* Landed: `pairFinite_ZAligned_iotaVL`, `pairFinite_yFam`, `pairFinite_ZAligned_iotaVL_self`,
  `pairFinite_shiftedField_ZAligned_iotaVL`, **`shiftedPairFiniteGenerators_of_nonneg`** (batch 180-B's
  recorded datum is now a theorem under `hs` and `∀ a b, 0 ≤ form a b`) and
  `pairFiniteHonestFields_of_nonneg`; and **`display8610TwoGenerators_iff_ratioForm_of_nonneg`** — the
  display's generator slice **is** the landed (8.4.25) ratio form, the datum discharged.
* **The batch-181-B "refutations" are vacuous**: `not_not_pairFinite_ZAligned_iotaVL` shows
  `not_display8610TwoGenerators` / `display8610TwoGenerators_false` / `not_display8610TwoOneSided` have an
  **unsatisfiable** hypothesis wherever `0 ≤ ⟨a,b⟩`.  `Display8610TwoGenerators`/`Display8610TwoOneSided`
  are neither proved nor refuted.
* **The exact Fock residual is now the created-state evaluation**:
  `display8610TwoGenerators_iff_createdState` — the generator slice is equivalent to the (8.5.5)
  evaluation of `YFam E a (−j−1) (creationExpVL b l (ι b))` for `l > 0`.  Open: `PairFinite` for
  `form a b < 0` (no finite (8.4.25) expansion there) and that evaluation.
* **A misreading of the source, corrected**: the docstrings' citation of "FLM Remark 8.5.2" for the
  infinite-sum claim was wrong — that Remark (printed p. 200) says the *created-state* identity (8.5.14)
  is not rigorous, while **Corollary 8.5.4 (printed p. 201) records "the sum being finite"**.

**B182-B ACCEPTED — `Definitions/MMFLM86NegTwoResidue.lean`** (467 lines, namespace `MM.FLM86NTR`,
12 guards, all exactly the three-axiom set).

* **At `⟨a,b⟩ = −2` nothing is left unreached on the evaluation side**: `coherentField_one` (the (8.5.5)
  one-step at `creationExpVL a 1 (anchorVL E a b)`, with the `^+` tail), `ZAligned_anchorVL`
  (`ZAligned E (anchorVL E a b) = ε(a,b) • YFam E (a+b)`) and `residueSum_negTwo_two_terms` — the whole
  `N = 2` residue equals two closed terms (degrees 0 and 1).
* **The exact residual is the commutator side**, named `NegTwoBlockCollapse` (the (8.4.26) chamber
  difference at `⟨a,b⟩ = −2` on some window equals the two closed terms; `normOrdered2`+`ratioCoeff`+
  `actionFamily` only — no `ZAligned`, no residue, no commutator), with
  `negTwoExactResidualAligned_iff_blockCollapse` **both directions**;
  `negTwoAndBelow_iff_exact_and_below` splits `≤ −2` into `= −2` and `≤ −3` (both ways).
* **Composition with the closed `−1` chain**: `residueNegativeAligned_evenCocycle_iff_negTwoAndBelow`
  — at `C.toCentralExtension h2` the negative-pairing residue is **exactly** `NegTwoBlockCollapse` +
  `NegThreeAndBelowResidualAligned`; `residueNegativeAligned_evenCocycle_of_blockCollapse` is the
  consumer form.
* This is the `N = 2` analogue of the closed `−1` chain (`AssemblyDiagonal` was the `z_0^0` line;
  `NegTwoBlockCollapse` is the `z_0^1` line).  `≤ −3` has no closed form and is left named, not faked.
* **Source-language finding**: the residue's states are the coefficients of the **negative** powers
  `z_0^{−N}…z_0^{−1}` of `Y(a,z_0)ι(b)` (the pole part, `latticeState_eq_exp`), while the landed
  display language is `ℕ`-indexed and *defines* the negative-power coefficients to be `0`
  (`creationCoeffZ_of_neg`) — so the landed (8.6.10) cannot even state the evaluations the residue needs.
  Also: the landed flat coefficients `MM.FLM8512.rhsFam`/`MM.FLM84T.coeff40Family` use
  `opOpenBox`/`openBoxCoeff`, which **drop the `^+` tail** of (8.4.16)
  (`MM.FLM85Ac.actionFamily_eq_opOpenBox_add_tail`); a residual stated with them would be the wrong
  statement, so the honest `actionFamily` form is used.

**The dispatcher's corrections of record (batch 182).**  The five false docstring paragraphs in
`MMFLM85OneSidedProduct.lean`, `MMFLM85OneSidedChain.lean` (`PairFiniteHonestFields`),
`MMFLM86OPEThird.lean` (two) and `MMFLM86TwoFactorDisplay.lean` (two) are rewritten in place as
"CORRECTION OF RECORD (batch 182)" blocks and the four modules rebuilt (`--- OK ---`, tokens at zero).
The corresponding paragraphs of this log and of `NOTES.md` §§75--78 are superseded by this entry and by
§79.

**Where Theorem 8.10.2 stands at the end of batch 182.**  `hjac` = `Corollary851 (ZAligned E) u v K`;
the lattice-pair cases `0 ≤ ⟨a,b⟩` and `⟨a,b⟩ = −1` are **closed**, and the live residuals are
**(1)** `NegTwoBlockCollapse` (`⟨a,b⟩ = −2`), **(2)** `NegThreeAndBelowResidualAligned` (`≤ −3`,
needing a closed form for the iterated (8.5.5) at degree `≥ 2`), **(3)** the Fock half's created-state
evaluation of `YFam E a (−j−1)(creationExpVL b l (ι b))`, and **(4)** the boundary restatement.
**Batch 183**: (A) `NegTwoBlockCollapse` — the batch-181 `AssemblyDiagonal` machinery one order higher;
(B) the coherent-state field `ZAligned E (creationExpVL a k (anchorVL E a b))` for general `k` by the
landed `ZAligned_creationStep` — the object shared by the `≤ −3` case and the Fock display.

**Brief errors this batch**: the `MMFLM86KF/EPA/TN.lean` file-name trap again;
`MM.FLM85PC.iterateStatement_ZAligned` does not exist (it is `MM.FLM85PC2.iterateStatement_ZAligned`, and
only at `b = ι(1)`); the general `MM.FLM85Ext.iterateStatement` is a `def … : Prop` **stated, not
proved**; the mode label of `creationCoeff` equals its anchor label; and the landed `ℕ`-indexed display
zeroes the negative-power coefficients.

---

### Batch 183 — the `−2` line needs the source cocycle: batch 182-B's `NegTwoBlockCollapse` is REFUTED as stated and the corrected residual is the WEIGHTED antidiagonal `NegTwoDiagonalWeight`; and the coherent-state field is a RECURSION, with the `≤ −3` case expanded to the honest (8.5.5) form

Four new files, two fresh agents, one batch; all verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B183-A ACCEPTED — `Definitions/MMFLM86NegTwoDiagonal.lean` (209 lines),
`MMFLM86NegTwoBlockCollapse.lean` (503 lines against a 300-line target, measured deviation reported),
`MMFLM86NegTwoBlockCollapseAux.lean` (204 lines)** (namespaces `MM.FLM86NTD`/`MM.FLM86NTB`; guards all
exactly the three-axiom set).

* **HEADLINE: batch 182-B's `NegTwoBlockCollapse` is REFUTED as stated** (it carries no cocycle
  hypothesis).  The proved obstruction: it forces `(E.eps a b − E.eps b a) • YFam E (a+b) (N−1) v = 0` for
  all `N, v`, i.e. by (7.1.26) `c(a,b) = 1` or `YFam E (a+b) ≡ 0` — the exact analogue of batch 177-B's
  refutation of `NegOneBlockCollapse`.  At `⟨a,b⟩ = −2` the source's own (8.4.34) condition
  `c(a,b) = (−1)^{⟨a,b⟩}` **is** `c(a,b) = 1`, so that hypothesis is the source's, not an extra one.
* **The corrected `c`-free residual is `NegTwoDiagonalWeight (E)`** — the `z_0^1` line of
  (8.4.36)/(8.4.40): a **weighted** antidiagonal sum (`diagSumWeighted (fun p ↦ ((p+m:ℤ):F))`) equals the
  two closed terms of batch 182-B's `residueSum_negTwo_two_terms` — together with `ZOneLineNegTwo` (the
  unweighted form at degree `−N`), and the proved equivalence
  `negTwoDiagonalWeight_iff_zOneLine` (both directions, using only the landed `AssemblyDiagonal`).
  The two-direction bridge to the batch-182 residual is
  `negTwoBlockCollapse_iff_diagonalWeight` under `hs` and `hc : form a b = −2 → E.c b a = 1`; the
  consumer at FLM's datum is
  `residueNegativeAligned_evenCocycle_of_diagonalWeight (h) (h3) : ResidueNegativeAligned`.
* **Why the `−2` line is genuinely new, and measured**: `ratioCoeff (−2) k = k + 1` (`ratioCoeff_neg_two`),
  so the chamber difference is a **weighted** antidiagonal sum with weight `p + m` — that extra factor is
  exactly why the batch-181 `AssemblyDiagonal` machinery (the `z_0^0` line) cannot close it.  The landed
  `MM.FLM86TPS.diagSumWeighted` (with window independence) is reused; the landed `z_0^1` lemmas
  `MM.FLM84DG.opOpenBox_deriv_modeFam`/`_heis` are the `z_2`-derivative at a **free** vertex operator
  with `DiagCollapse`/`DerivNormalOrdered` as hypotheses, not the carrier identity.

**B183-B ACCEPTED — `Definitions/MMFLM86CoherentField.lean`** (371 lines, namespace `MM.FLM86CF2`,
13 guards, all exactly the three-axiom set).

* **The honest provable form of the coherent-state field is a RECURSION, not a closed form**:
  `coherentStep E a w k = ((k+1:ℚ)⁻¹) • Σ_{r<k+1} reflectFam (actionFamily (factorFactorZero (r+1) … a)
  (YzeroField (baseAligned E) (creationExpVL a (k−r) w)))`, `coherentFieldNat` its `Nat.rec` from
  `ZAligned E w`, and `coherentField_recursion / coherentFieldNat_eq / coherentField_pos` the three
  forms of the statement: **degree `k+1` = one (8.5.5) step against the fields of the lower coherent
  states** (`^+` tail included), bottoming out at the closed anchor `ε(a,b)•YFam E (a+b)`.  `k = 0/1`
  reproduce batch 182-B's landed cases.  The identity that would collapse the recursion
  (`Y(E⁻(z₀)w,z) = 8E⁻(z₀)Y(w,z)8`) is **not landed** (it is the `NonvacuumCreatedStep`-adjacent
  input, and `conv` is a forbidden route); the self-reference is made a theorem
  (`YzeroField_creationExpVL_fam`), not a hidden step.
* **The `≤ −3` case is expanded to the honest carrier form**:
  `NegThreeExpandedResidualAligned` with
  `negThreeResidualAligned_iff_expanded : NegThreeAndBelowResidualAligned E ↔
  NegThreeExpandedResidualAligned E` (both directions), replacing every summand's
  `ZAligned E (creationExpVL a (N−1−i) anchorVL)` by `coherentFieldNat E a anchorVL (N−1−i)`; and
  `residueDegree_eq`: the `i`-th (8.5.26) summand's state index is the degree `N−1−i`.
* **The Fock display is NOT reachable by this route** (measured): its left-hand object is
  `ZAligned E (YFam E a (−j−1) (creationExpVL b l (ι b)))` — an honest **mode of `a`** applied to the
  coherent state of `b` — not `ZAligned E (creationExpVL a k anchor)`; reaching it needs an intertwining
  at the honest modes, which is not landed.

**Where Theorem 8.10.2 stands at the end of batch 183.**  `hjac` = `Corollary851 (ZAligned E) u v K`;
the lattice-pair cases `0 ≤ ⟨a,b⟩` and `⟨a,b⟩ = −1` are **closed**; the live residuals are
**(1)** `NegTwoDiagonalWeight` (the weighted `z_0^1` line at `⟨a,b⟩ = −2`), **(2)**
`NegThreeExpandedResidualAligned` (the recursion form of `≤ −3`), **(3)** the Fock half's created-state
evaluation (now known to need a mode intertwining), and **(4)** the boundary restatement.
**Batch 184**: (A) `NegTwoDiagonalWeight` — the weighted antidiagonal identity; (B) the recursion
collapse for `≤ −3`, or the honest-mode intertwining if the collapse is out of reach.

**Brief errors this batch**: the batch-181 machinery is the `z_0^0` line and is already landed;
`ratioCoeff (−2) k = k+1` makes the `−2` line weighted; `NegTwoBlockCollapse` is the analogue of the
**refuted** `NegOneBlockCollapse`, not of `AntidiagonalCollapse`; `ZAligned` exists twice
(`MM.FLM810JZF`, `MM.FLM810JF2`, definitionally equal); and "induction on `k`" for the coherent field
yields a recursion, not an evaluation.

---

### Batch 184 — the `−2` residual is the `p = 1` line of the landed display family `diagFam` (a both-directions reduction, cocycle discharged); and the honest-mode intertwining evaluates the Fock LHS as a ratio sum of the coherent recursion

Two new files, two fresh agents, one batch; both verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B184-A ACCEPTED — `Definitions/MMFLM86NegTwoWeighted.lean`** (361 lines, namespace `MM.FLM86NTW`,
9 guards, all exactly the three-axiom set).

* **The weighted identity is NOT proved; the exact both-directions reduction is landed.**  New named
  residual `NegTwoDisplayZOne (E)`: for `form a b = −2`, the **unweighted** `p`-antidiagonal sum
  (`diagSumWeighted (fun p ↦ (p:F))`) equals `iteratePow (ZAligned E) (ι a) (ι b) (form a b + 1) (m+n) v`
  — i.e. **the `p = 1` coefficient of the landed display family `MM.FLM86D86.diagFam`/`displayP`**.
* Equivalences, both directions: `zOneLine_iff_displayZOne` (no hypotheses),
  `negTwoDiagonalWeight_iff_displayZOne`, `negTwoExactResidualAligned_iff_displayZOne` (under
  `hc : form a b = −2 → E.c b a = 1`), and **`negTwoExactResidualAligned_evenCocycle_iff_displayZOne`**
  with the cocycle discharged at `C.toCentralExtension h2`; conditional consumer
  `residueNegativeAligned_evenCocycle_of_displayZOne`.
* Unconditional support: `diagSumWeighted_eq_diagSum_firstDeriv` (the weight is the trivial
  `p = m+1` reindexing of the first-variable derivative), `diagFam_one_eq_diagSumWeighted`,
  `diagFam_zero_eq_diagSum` (**the `p = 0` line IS the landed `assemblyDiagonal`**),
  `ZAligned_creationExpVL_one_apply` (the (8.5.11) evaluation of the created state) and
  `zOneLine_diagFam`.
* **Route correction (measured)**: the weight is **not** the (8.4.25) expansion differentiated — it is
  the (8.2.14) falling factorial `binomCoeff m 1 = m`, i.e. the `z_0^1` coefficient of the landed
  display family.  And the landed (8.4.40) `z_0^1` lemmas
  (`MM.FLM84DG.opOpenBox_deriv_modeFam(_heis)`, `MM.FLM8512.productExpansion8512_apply_one`) **cannot be
  instantiated at the boundary field at all**: they carry a negative-power vanishing `hX` that is false
  for `YFam E a` (component `−1` is `creationExpVL a (−1−form a c)(anchorVL E a c)`, nonzero at pairing
  `−1`; `MM.FLM84LF.YFam_iotaVL`).

**B184-B ACCEPTED — `Definitions/MMFLM86ModeIntertwine.lean`** (472 lines, namespace `MM.FLM86MI`,
13 guards, all exactly the three-axiom set).

* **The honest-mode intertwining is landed** (symmetric form, `0 ≤ ⟨a,b⟩`):
  `modeIntertwine : YFam E a M1 (ZAligned E (ι b) M2 v) = Σ_{i ≤ ⟨a,b⟩} ratioCoeff ⟨a,b⟩ i •
  normOrdered2 a b (−M1−1+i−⟨a,b⟩) (−M2−1−i) v` — an honest mode of `a` applied to an honest-mode-created
  state is the finite (8.4.25) ratio sum of normal-ordered blocks.  Lattice-generator slice:
  `ZAligned_mode_iotaVL` (`ZAligned E (YFam E a q (ι c)) = ε(a,c) • (if 0 ≤ −q−1−⟨a,c⟩ then
  coherentFieldNat E a (ι(a+c)) ((−q−1−⟨a,c⟩).toNat) else 0)`).
* **The Fock LHS is now fully evaluated**: `ZAligned_createdState` writes
  `ZAligned E (YFam E a (−j−1)(creationExpVL b l (ι b)))` as a finite ratio sum whose summands are batch
  183-B's `coherentFieldNat` at the **coherent anchors** — no field at a mode-applied state remains.  And
  **`display8610TwoGenerators_iff_coherentForm`** (both directions) identifies the display's generator
  slice with `CoherentCreatedForm`.
* New (8.6.9)-side facts: `normOrdered2_vacuum` (the block on `ι(1)` is the double coherent state
  `E⁻_a(z₁)E⁻_b(z₂) anchorVL E a b`) and `ZAligned_normOrdered2_vacuum` (its field is the coherent
  recursion), plus the required bridge **`ZAligned_JZF_eq : FLM810JZF.ZAligned = FLM810JF2.ZAligned`** —
  the repository carries two syntactically distinct, definitionally equal copies, and `rw` cannot cross
  them (CF2 speaks JZF, the (8.6.10) chain speaks JF2); successors must use the bridge.
* Correction: `ZAligned_creationStep`/`ZAligned_spec_cons` are **not** consumed — the Fock mode is the
  assembled `YFam`, not a Heisenberg creation monomial (on a lattice generator `YFam E a q (ι c)` is an
  infinite combination of modes).

**Where Theorem 8.10.2 stands at the end of batch 184.**  `hjac` = `Corollary851 (ZAligned E) u v K`;
`0 ≤ ⟨a,b⟩` and `⟨a,b⟩ = −1` are **closed**; the live residuals are **(1)** `NegTwoDisplayZOne` (the
`p = 1` line of the landed `diagFam` family, the `⟨a,b⟩ = −2` case), **(2)** the `≤ −3` case in the
coherent-recursion form, **(3)** `CoherentCreatedForm` (the Fock comparison identity), and **(4)** the
boundary restatement.  **Batch 185**: (A) `NegTwoDisplayZOne` — look for the `p`-recursion of
`diagFam`/`displayP` (the `p = 0` line is `assemblyDiagonal`, so a recursion in `p` would give
`p = 1`); (B) `CoherentCreatedForm` — the (8.6.9)/(8.6.10)-at-`k = 2` re-expansion
`Y(8Y(a,z₁)Y(b,z₂)8 ι(1), z)`.

**Brief errors this batch**: the "differentiate (8.4.25)" route for the weight; the claim that the
(8.4.40) `z_0^1` lines apply at the boundary field (their `hX` fails); "equivalently `ZAligned E
(modeVL a m x)`" for the intertwining; and the new Lean traps (`Finset.sum_subset`'s orientation and
metavariable, the `zsmul` elaboration of an `End`-scalar product, the explicit `LinearMap.smul_apply`).

---

### Batch 185 — the `−2` case reduces to a DERIVATIVE normal-ordering identity (`NegTwoFirstDerivZero`; the `p`-recursion route is refuted by counterexample); and `CoherentCreatedForm` is pinned as one dictionary with `CoherentCreatedStep` and the landed `IterateProductStep`

Three new files, two fresh agents, one batch; all verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B185-A ACCEPTED — `Definitions/MMFLM86NegTwoPOne.lean`** (418 lines, namespace `MM.FLM86NPO`,
9 guards, all exactly the three-axiom set).

* **The brief's `p`-recursion route is REFUTED by counterexample**: `diagFam_apply` makes `diagFam` the
  diagonal Taylor family of the substituted `X(z₂+z₀,z₂)`, and its `p = 0` and `p = 1` coefficients read
  **different** coefficients of `X` (`X m (−j−1−m)` versus `X m (−j−m)`);
  `exists_diagFam_zero_eq_zero_one_ne_zero` exhibits, for every nonzero `v`, a family with vanishing
  `p = 0` line and nonvanishing `p = 1` line.  So the landed `p = 0` line (`assemblyDiagonal`) cannot
  give `p = 1`.
* Landed instead: **the complete `p`-recursion** `diagFam_succ_eq_diagFam_firstDeriv`
  (`(p+1) • diagFam X M1 M2 (p+1) j = diagFam (firstDeriv X) (M1−1) M2 p j`), i.e. every step replaces
  `X` by `∂_{z₁}X` and only the `p = 0` line is evaluated; and **the exact named sub-residual
  `NegTwoFirstDerivZero (E)`** — the `p = 0` line of `firstDeriv (normOrdered2 a b)` equals
  `ZAligned E (creationExpVL a 1 (anchorVL E a b)) (m+n) v` — with **both directions**:
  `zOneLine_iff_firstDerivZero`, `negTwoDisplayZOne_iff_firstDerivZero` and
  `negTwoExactResidualAligned_evenCocycle_iff_firstDerivZero` at `C.toCentralExtension h2`.
* **The honest remaining input is a Leibniz/normal-ordering identity, not bookkeeping**:
  `∂_{z₁}|_{z₁=z₂} 8Y(a,z₁)Y(b,z₂)8 = 8a(z₂)Y(ab,z₂)8` (source reading
  `∂_z Y(u,z) = Y(L₋₁u,z)`, `L₋₁ι(a) = a(−2)1`) — a **weight-two Fock field times a lattice field**,
  outside the batch-180/181 two-lattice-label fibre computation.
* The only landed statement yielding the display's `z_0^1` line,
  `MM.FLM8512Done.productExpansion8512_apply_one`, is not a route: it assumes the whole display
  `ProductExpansion8512` (not landed at `⟨a,b⟩ = −2`) and a negative-power vanishing `hX` that is
  **false** at `ZAligned`.
* Recommended routes for the successor: (i) the (8.4.36) substitution at `z_0^1` via the landed
  resummation layer (`MM.FLM84Taylor.resumCoeff`/`taylorCoeff`, `MMFLM86TaylorOperator`) applied to the
  `E⁻`/block/`E⁺` decomposition of `normOrdered2`; (ii) generalise the batch-180/181 fibre computation
  from `normOrdered2 a b` to `8Y(u,z₁)Y(b,z₂)8` for a general Fock state `u` (there `u = a(−2)1`).

**B185-B ACCEPTED — `Definitions/MMFLM86CoherentCreated.lean` (352 lines) and
`MMFLM86CoherentCreatedStep.lean` (160 lines)** (namespaces `MM.FLM86CCF`/`MM.FLM86CCS`; 13 guards,
all exactly the three-axiom set).

* **`CoherentCreatedForm` is NOT landed, and the hoped-for "same normal-ordered object" does not exist**:
  the landed (8.4.25) expansions give the LHS as a ratio sum of **fields at** normal-ordered blocks (the
  (8.6.9) currency) and the RHS as a window sum of normal-ordered blocks **applied to a state** — different
  currencies, different index sets, no reindexing.
* The exact residual is `MM.FLM86CCF.CoherentCreatedStep (E)` ((8.4.25) at the non-vacuum created state
  = (8.5.14)/(8.6.10) at `k = 2`), and the **both-directions** dictionary
  `coherentCreatedForm_iff_createdStep` (under `hs` and `0 ≤ ⟨a,b⟩`), plus
  `coherentCreatedForm_iff_normOrdered2` (the termwise (8.6.9) reading) and
  `coherentCreatedForm_iff_ratioForm(_nonneg)` (↔ `RatioForm8610TwoGenerators`, datum discharged).
* The sibling lands the implication chain `IterateProductStep (ZAligned E) convOneSided ⇒
  Display8610TwoOneSided ⇒ Display8610TwoGenerators ⇒ CoherentCreatedForm` (no `hnd`) and
  `createdStep_of_iterateProductStep` (with the landed `k = 1` display, hence `hnd`/`hs`).  So the Fock
  half's four statements are now **one dictionary**, all implied by the repository's already-named
  `IterateProductStep (ZAligned E) convOneSided` (the converse is unavailable — it quantifies over all
  states).

**A correction of record.**  Batch 178-A's report that `Definitions/MMFLM85StepLinear.lean` "is imported
by nothing" is **wrong**: `FinalCheck.lean:343` has imported it since batch 128 (commit `94b9097`), and
`MMFLM85NonvacuumStep.lean:47` imports it too.  The batch-178 entry's "repo trap worth keeping" is
withdrawn; the module is on the delivery path.

**Where Theorem 8.10.2 stands at the end of batch 185.**  `hjac` = `Corollary851 (ZAligned E) u v K`;
`0 ≤ ⟨a,b⟩` and `⟨a,b⟩ = −1` are **closed**; the live residuals are **(1)** `NegTwoFirstDerivZero` (the
derivative normal-ordering identity, `⟨a,b⟩ = −2`), **(2)** the `≤ −3` case, **(3)**
`CoherentCreatedStep` (the Fock comparison), and **(4)** the boundary restatement.
**Batch 186**: (A) `NegTwoFirstDerivZero` by the recorded routes; (B) `CoherentCreatedStep`.

**Brief errors this batch**: the `p`-recursion route (refuted); "compare coefficientwise at the coherent
anchors" (the sums have different index sets); `MM.FLM86M.Display869`/`Display8610` are vacuous defs;
`ZAligned_JZF_eq` is not needed for the Fock target; and the "orphan module" claim.

---

### Batch 186 — the even-cocycle boundary theorem and the FACE AUDIT (only `l = 0` has producers; the `l ≠ 0` faces are untouched territory); and the `convWith2` Leibniz rule splits the `−2` derivative residual into three fibre collapses

Two new files, two fresh agents, one batch; both verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B186-B ACCEPTED — `Definitions/MMFLM810TheoremEven.lean`** (300 lines, namespace `MM.FLM810TE`,
6 guards, all exactly the three-axiom set).  **The audit is the deliverable.**

* **The even-cocycle boundary is landed**:
  `theorem8102_of_residuals (hnd) (hs) (C : EvenCocycle L form) (h2) (S) (hpd) (hW) (hfin)
  (hstep : EvenCocycleJacobiStep C h2) (hres : EvenCocycleResiduals C h2) : Theorem8102`, with
  `EvenCocycleResiduals C h2 := NegTwoFirstDerivZero E ∧ NegThreeExpandedResidualAligned E ∧
  CoherentCreatedStep E` at `E := C.toCentralExtension h2`, and
  `EvenCocycleJacobiStep C h2 := EvenCocycleResiduals C h2 → JacobiEvenCocycle C h2` (the
  residual-to-`hjac` step, named).  Also: `theorem8102_of_evenJacobi`,
  `theorem8102_of_jacobiResidual` (`JacobiResidualAligned` + `Proposition8107` → `Theorem8102`),
  `FockCreatedStep` + `coherentCreatedStep_of_fockCreatedStep`, and the both-directions
  `residueNegativeAligned_evenCocycle_iff_residuals`.
* **A formalization gap is closed**: batch 169 R1's "`JacobiOnStateTargets` ⟺ `JacobiAxiom`" had only
  one direction in the tree; this file lands the converse
  (`jacobiOnStateTargets_of_jacobiAxiom`, `jacobiAxiom_iff_stateTargets`), so the §8.10 output can now
  feed the boundary.
* **THE AUDIT (every claim file:line in the file's header)**:
  * `Res_{z_0}` (`MMFLM88.res_z0_face`, literally `h 0 m n`) **is** Corollary 8.5.1.  At the
    even-cocycle field: `0 ≤ ⟨a,b⟩` unconditional (batch 170), `⟨a,b⟩ = −1` unconditional (batch 181);
    open: `⟨a,b⟩ = −2` = `NegTwoExactResidualAligned` ≡ `NegTwoFirstDerivZero`, `≤ −3` =
    `NegThreeAndBelowResidualAligned` ≡ `NegThreeExpandedResidualAligned`, and the Fock half =
    `CoherentCreatedStep` (implied by `IterateProductStep (ZAligned E) convOneSided`).
  * `Res_{z_1}`/`Res_{z_2}` (`MM.FLM88.res_z1_face`/`res_z2_face`) are **extractions from the Jacobi
    hypothesis**, not independent theorems; their only conditional content is
    `MM.FLM810JacobiRoute.lean:147`/`:179`, both taking `h : JacobiIdentity`.
  * **`l, m, n ≠ 0`: NOTHING landed.**  So `hjac` is strictly more than `Corollary851`: only its
    `l = 0` face has producers.  *This is the campaign's largest untouched gap.*
  * Route §8.8 (Theorem 8.8.9, whose proof repeats Theorem 8.6.1's, printed p. 231): landed is the
    `JacobiIdentity ↔ JacobiDelta` equivalence and the extraction halves; missing is the identity itself,
    the §8.6 engine ((8.6.5)/(8.6.6)/(8.6.8)/(8.6.9--10)) and the frontier `Source861Aligned` ⟺
    `Residual861Aligned`.
  * Route §8.10: `Proposition8103/8104/8105/8107` are all `def … : Prop`; landed and consumable is the
    calculus (`theta_eq_commutator`, `commutativity_iff_theta_zero`, σ `substFormAlg_iff` — the naive
    `SubstForm` iff being **false**, `(8.10.73)`, `recoverySplit_exists`); missing is the `ι_{12}`-bridge
    (measured unprovable as landed), `RecoveryDisplay`, the `RecoverySplit` use, and 8.10.7.
* **Unconditional `Theorem8102` needs**: (i) `NegTwoFirstDerivZero`; (ii) `NegThreeExpandedResidualAligned`;
  (iii) the Fock dictionary; (iv) `EvenCocycleJacobiStep` — i.e. the `l ≠ 0` faces plus the assembly from
  `Res_{z_0}` to (8.10.8) (Theorem 8.8.9 or Proposition 8.10.7); plus the six boundary inputs.
  **Recommended next batches**: the `l ≠ 0` faces (untouched; `MMFLM810Route` has the swap machinery),
  then the §8.10 `ι`-bridge or the §8.6 engine, and keep the Fock gap named as `IterateProductStep`.

**B186-A ACCEPTED — `Definitions/MMFLM86FirstDerivLine.lean`** (394 lines against a 300-line target,
reported; namespace `MM.FLM86FDL`, 9 guards, all exactly the three-axiom set).

* **The `convWith2` Leibniz rule is landed** (the flat `deriv_flatMul` of batch 179 does not apply to the
  two-variable Cauchy product): `firstDeriv_convWith2 : firstDeriv (convWith2 X Y hY) =
  convWith2 (firstDeriv X) Y hY + convWith2 X (firstDeriv Y) (locallyFinite2_firstDeriv hY)`, with
  `locallyFinite2_firstDeriv`; hence the three-piece decomposition
  `firstDeriv_normOrdered2_eq : firstDeriv (normOrdered2 E a b) = creationDerivPiece E a b +
  blockDerivPiece E a b + annihDerivPiece E a b` (one factor differentiated per piece), plus the factor
  derivatives (`firstDeriv_creationPair2_flatMul` via the landed `MM.FLM84DY.deriv_creationExpVL`,
  `firstDeriv_annihPair2`, `firstDeriv_midBlock2`) and `diagSum_add`.
* The `−2` residual is restated, **both directions**, as `FirstDerivThreeFactorLine (E)`
  (`negTwoFirstDerivZero_iff_threeFactor`, `negTwoExactResidualAligned_evenCocycle_iff_threeFactor`) —
  an equivalent form whose left-hand side is closed and whose content is three explicit per-state
  diagonal collapses of landed `convWith2` expressions.
* **Measured advice for the successor**: attack `creationDerivPiece` first (its `E⁻` fibre collapse is
  available from `flatMul_creationExpVL`/`sum_creationPair2_fiber` plus `deriv_creationExpVL`); the
  `−2` line is **weighted**, so the batch-181 regrouping cannot be reused verbatim (the weight couples to
  the creation index); and the route-(ii) picture "`:Y(a(−2)1,z₁)Y(b,z₂):`" would first need a landed
  `Y(u,z)` for Fock `u` plus a `firstDeriv = Y(L₋₁·)` bridge — neither exists.

**Where Theorem 8.10.2 stands at the end of batch 186.**  The boundary is now stated honestly at the
even cocycle, with the exact input list; the `l = 0` face is closed for `0 ≤ ⟨a,b⟩` and `⟨a,b⟩ = −1` and
reduced elsewhere; the `l ≠ 0` faces and the two continuations are the campaign's remaining fronts.

**Brief errors this batch**: `MM.FLM86TK.*` does not exist (the θ layer is `MM.FLM810TK`);
`convWith2` vs `flatMul` conflated; the resummation layer adds nothing past batch 185-A; and route (ii)
needs two unlanded bridges.

---

### Batch 187 — the `l ≠ 0` front is OPENED (the degenerate `l ≥ 0` chamber at `0 ≤ ⟨a,b⟩` is a theorem; the `l < 0` iterate side is computed; the first genuinely nonzero face is named); and the `−2` creation piece is collapsed

Three new files, two fresh agents, one batch; all verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B187-A ACCEPTED — `Definitions/MMFLM810JacobiNonzeroFaces.lean`** (300 lines, namespace `MM.FLM810JNF`,
2 guards, both exactly the three-axiom set).  **The largest gap of the campaign now has land.**

* **Inventory**: the only general-`l` statements in the tree were `JacobiIdentity`/`JacobiDelta` (defs),
  the reindexing `jacobiIdentity_iff_delta`, the window-stability `crossBracket_eq_of_window`, and
  `res_z1_face`/`res_z2_face`/`corollary8818_of_jacobiIdentity` — **all conditional on
  `h : JacobiIdentity`** (extractions, no computation).  At the boundary field, only `l = 0` had
  producers; the sole landed `l ≠ 0` identity anywhere was the scalar toy model
  (`MMFLM810ScalarJacobi.lean:542`, whose `Y` is not a VOA field).
* **Landed at the boundary field `ZAligned E`, `E = C.toCentralExtension h2`**:
  `crossTerm_ZAligned_lattice` (+ `crossTermSwap`), `yFam_mul_comm_of_nonneg`,
  `deltaExpCoeff_reflect_of_nonneg`, `sum_crossTerms_eq_smul_sum_crossTermSwaps` (the (8.8.21) swap
  identity), and the **first `l ≠ 0` face**: `crossBracket_ZAligned_lattice_of_nonneg = 0` and
  `crossIterate_ZAligned_lattice_eq_zero_of_nonneg = 0`, hence
  **`crossBracket_eq_crossIterate_ZAligned_lattice_of_nonneg`** — the two sides are **equal for every
  `l ≥ 0`, every `m, n`, and every `N ≥ l.toNat + 1`** (both zero) at `0 ≤ ⟨a,b⟩`.
* **The `l < 0` iterate side is computed**:
  `crossIterate_ZAligned_lattice_eq_sum_of_nonpos` — the explicit finite sum over `i < (−l).toNat` of
  `binom(m,i) • iterateOf (ι a) (ι b) (l+i) (m+n−i)`.
* **The named residual `FirstNegativeFaceAligned (E)`** — the `l = −1` face at `0 ≤ ⟨a,b⟩` (the first
  face with genuinely nonzero sides), with the consumer
  `jacobiIdentity_neg_one_slice_of_firstNegativeFace` yielding exactly that slice of (8.8.41) in the
  per-monomial `∃N` shape of (8.10.8).
* **Route correction**: no landed reduction of a general `l ≠ 0` face to `l = 0` exists, and the book's
  shift display is (8.6.28) (which the source itself calls "formal ... suggestive"), not (8.6.29)/(8.6.30)
  (the iterate definition and the commutator formula); for `l ≥ 0` the face reduces to a sum of
  **commutators** (landed here), not to `l = 0` plus a shift.  **Next target: the `l = −1` face**,
  through the landed (8.4.25) product, not by reindexing.

**B187-B ACCEPTED — `Definitions/MMFLM86CreationDerivPiece.lean` (576 lines) and
`MMFLM86CreationDerivPieceLine.lean` (344 lines)** (namespaces `MM.FLM86CDP`/`MM.FLM86CDPL`;
13 guards, all exactly the three-axiom set).

* **The `E⁻` fibre collapse is landed**: `sum_creationDerivPair_window` — the fibre sum is
  `flatMul (deriv E⁻_a) E⁻_b` (one of the two orderings) — together with
  `flatMul_deriv_creationExpVL_add : deriv E⁻_{a+b} = flatMul (deriv E⁻_a) E⁻_b +
  flatMul (deriv E⁻_b) E⁻_a`.  Hence **no single piece can equal the target's right-hand side**: the
  creation piece carries exactly half the derivative.
* `diagSum_creationDerivPiece(_regrouped)` (the diagonal sum of the creation piece **is** the
  double-window sum of the collapsed factors), `diagSum_blockDerivPiece` (the block's first layer), and
  `sum_sum_window_regroup_factor` — batch 181's regrouping with an **arbitrary** factor, with
  `sum_sum_window_regroup_landed_agrees` proving its `C = creationExpVL (a+b)` instance is
  *syntactically* the landed `MM.FLM86AR.sum_sum_window_regroup` (an independent cross-check).
* **Pieces**: creation **LANDED**; block **LANDED to the first layer** (its second layer — the weighted
  antidiagonal sum of the differentiated `a(0)` block, value `⟨a,c⟩` on `x ⊗ ι(c)` — is open);
  annihilation **NOT landed** (the mirrored flat recursion `(d/dz)E⁺ = −a(z)⁺E⁺` is absent at the
  carrier).  The residual is restated as `CreationClosedLine`/`CreationBlockClosedLine`
  (**both directions**).
* **Corrections**: the brief's "`Σ_fibre (dE⁻_a)E⁻_b = d(E⁻_{a+b})`" is **false** (the two orderings each
  contribute half); and the weight warning is only half right — `dE⁻_a`'s extra index `i = −1` carries
  weight `0`, so the window/containment hypothesis is **verbatim** batch 181's and the regrouping is
  reusable with the factor replaced (proved).

**Where Theorem 8.10.2 stands at the end of batch 187.**  Both remaining fronts now have land: the
`l = 0` face is closed for `0 ≤ ⟨a,b⟩` and `⟨a,b⟩ = −1` (with `−2`, `≤ −3`, Fock named), and the
`l ≠ 0` front has its degenerate chamber (`l ≥ 0`, `0 ≤ ⟨a,b⟩`) as a theorem, its `l < 0` iterate side
computed, and its first nonzero face named `FirstNegativeFaceAligned`.  **Batch 188**: (A) the `l = −1`
face; (B) the annihilation derivative piece (the mirror of `creationDerivPiece`).

**Brief errors this batch**: the shift-display attribution (`(8.6.28)`, not (8.6.29)/(8.6.30)); "nothing
landed for `l ≠ 0`" (the scalar toy model was landed, though not at the boundary field); the "`l ≠ 0`
reduces to `l = 0` plus a shift" picture; the `E⁻` fibre-sum identity; and the `sum_creationPair2_fiber`
name (`sum_creationPair2_antidiagonal`/`sum_creationPair2_window`/`sum_annihPair2_fiber` are the real
ones).

---

### Batch 188 — the `l = −1` face becomes a pure honest-lattice-VOA identity `(∗)` (both directions, all boundary-field ingredients discharged); and the `E⁺` mirror collapse lands the third Leibniz piece of the `−2` case

Three new files, two fresh agents, one batch; all verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B188-A ACCEPTED — `Definitions/MMFLM810NegOneFace.lean`** (445 lines against a 300-line target,
reported; namespace `MM.FLM810NOF`, 7 guards, all exactly the three-axiom set).

* **The cross side is the WHOLE diagonal**: `deltaExpCoeff i (−1) = 1` (char 0, the factorial hypothesis
  discharged) and `(−1)^{−1} = −1` give
  `crossBracket (ZAligned E) (ι a) (ι b) N (−1) m n = Σ_{i<N} YFam a (m−1−i)·YFam b (n+i) +
  Σ_{i<N} YFam b (n−1−i)·YFam a (m+i)` — the two halves of `p+q = m+n−1` of the honest product (not
  merely a δ-term: it is (8.6.28) at `z_0^0`).
* **The iterate side is a closed form** (`crossIterate_ZAligned_lattice_neg_one`,
  `iterateOf_…_eq_ite`): the iterate state is `creationExpVL a (−⟨a,b⟩)(anchorVL E a b)`, so
  `iterateOf (ZAligned E) (ι a) (ι b) (−1) (m+n) = if ⟨a,b⟩ = 0 then ε(a,b)·YFam (a+b) (m+n) else 0`.
  **The boundary-field repair drops out of this face.**
* **The residual `NegOneFaceAligned (E)`** — the source's per-element reading (printed p. 244) — is
  proved **equivalent, both directions** (`negOneFaceAligned_iff_crossBracket`), to the **pure
  honest-lattice-VOA identity**
  `(∗) Σ_{p+q=m+n−1} YFam a p · YFam b q = (0 if ⟨a,b⟩ ≠ 0 else ε(a,b)·YFam (a+b) (m+n))`, per element.
  **`(∗)` contains no `ZAligned`**, so any honest-VOA proof of it makes the `l = −1` slice
  unconditional.  Also landed unconditionally: the cross-side finiteness from (8.10.5)
  (`crossWindowOn_ZAligned_lattice_neg_one`), the transport `negOneFaceAligned_of_firstNegativeFace`
  (batch 187-A's def ⟹ the source reading), and the slice consumer
  `jacobiIdentity_neg_one_slice_of_negOneFace`.
* **Slices unconditional today**: `l = 0` and `l ≥ 0` (at `0 ≤ ⟨a,b⟩`).  **Not landed**: `(∗)` itself,
  i.e. the two chambers (`1 ≤ ⟨a,b⟩`: cross side 0; `⟨a,b⟩ = 0`: cross side `= ε·YFam (a+b)`).
* **Corrections**: the "reduce to the landed `l = 0` face" advice is unsupported (there the `l = 0` face is
  commutativity with both sides 0 and carries no information on the diagonal sums); and batch 187-A's
  `FirstNegativeFaceAligned` window conjunct is **operator-valued**, which — by the repo's own W5/W7
  measurement (`jacobi8108_iff_zeroProduct`) — is *not* the source's per-element reading; this batch
  states the residual per element and proves only 187-A ⟹ mine (the converse needs operator-level
  vanishing, not supplied by (8.10.5)).  **Naming collision recorded**: `MM.FLM86RN.NegOneResidualAligned`
  is the `⟨a,b⟩ = −1` *pairing* at `l = 0`, a different object from this `l = −1` face.

**B188-B ACCEPTED — `Definitions/MMFLM86AnnihDerivPiece.lean` (708 lines) and
`MMFLM86AnnihDerivPieceLine.lean` (332 lines)** (namespaces `MM.FLM86ADP`/`MM.FLM86ADPL`; 15 guards,
all exactly the three-axiom set).

* **The mirror flat recursion and the `E⁺` fibre collapse are landed**:
  `deriv_annihExpField`, `deriv_annihIdx` (the mirrored recursion),
  `flatMul_deriv_annihIdx_add : flatMul (deriv (annihIdx a)) (annihIdx b) +
  flatMul (annihIdx a) (deriv (annihIdx b)) = deriv (annihIdx (a+b))`, and
  `sum_annihDerivPair_window` (the exact analogue of batch 187-B's `sum_creationDerivPair_window`,
  with the minus sign and the shift `−K−2`), plus its total-degree form and
  `diagSum_annihDerivPiece(_regrouped)` — **all three Leibniz pieces are now in one collapsed normal
  form**.  The generalized regrouping engine `sum_sum_window_regroup_gen` is landed (the landed batch-181
  engine is its `g = annihPair2` instance).
* **Exact residual `AnnihClosedLine`** (the `FirstDerivThreeFactorLine` equation with the three
  `diagSum`s collapsed; one extra conjunct: the block must kill the derivative annihilation pair),
  **both directions** (`firstDerivThreeFactorLine_iff_annihClosed`,
  `negTwoFirstDerivZero_iff_annihClosed`, and at FLM's datum
  `negTwoExactResidualAligned_evenCocycle_iff_annihClosed`).
* **The pieces do NOT assemble yet**, for two measured reasons: (i) the block's **second layer** is missing
  (at the carrier the derivative block's fibre collapse is operator-valued/per-state, not a single
  `z^{(a+b)(0)}` collapse); (ii) each exponential piece carries only **one ordering** of its derivative,
  while the residual's identification with `ZAligned E (creationExpVL a 1 (anchorVL E a b))`
  ((8.4.23)/(8.4.25)) is not landed.  **Corrections**: the "mirror" is an **index reflection**
  `i ↦ −i−1` (same ordering, giving the minus sign and the shift), and the brief's "only the block's
  second layer remains" was false.

**Where Theorem 8.10.2 stands at the end of batch 188.**  Unconditional slices: `l = 0` (at `0 ≤ ⟨a,b⟩`
and `⟨a,b⟩ = −1`, with `−2`/`≤ −3`/Fock named) and `l ≥ 0` (at `0 ≤ ⟨a,b⟩`).  The `l = −1` slice is
conditional on the pure VOA identity `(∗)`; the `−2` case on the three-piece assembly.  **Batch 189**:
(A) the two chambers of `(∗)`; (B) the block's second layer / the ordering identification for the
`−2` case.

**Brief errors this batch**: "the cross side is the δ-term"; the "reduce to `l = 0`" route; the
operator-valued window (187-A) vs the per-element reading (the source); the "`annih` is the other
ordering" picture; and the `sum_sum_window_regroup_factor` reuse claim.

---

### Batch 189 — MILESTONE: `(∗)` and the `l = −1` slice are UNCONDITIONAL at FLM's datum; the `−2` assembly reduces to the (8.4.23) dictionary, and the "missing ordering" premise is REFUTED

Five new files, two fresh agents, one batch; all verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B189-A ACCEPTED — `Definitions/MMFLM810NegOneChambers.lean` (353 lines) and
`MMFLM810NegOneChambersClose.lean` (232 lines)** (namespaces `MM.FLM810NOC`/`MM.FLM810NOCC`;
14 guards, all exactly the three-axiom set).

* **Both chambers of `(∗)` are landed**: `honestDiag_eq_zero_of_one_le` (`1 ≤ ⟨a,b⟩`: the diagonal sum
  vanishes) and `honestDiag_eq_eps_smul_of_eq_zero` (`⟨a,b⟩ = 0`: it equals
  `ε(a,b)·YFam (a+b) (D+1)`), and **`(∗)` itself unconditionally**:
  `diagSum_honestDiag_eq` — the value is **window-independent** (`exists_honestDiag_window`), so only the
  form symmetry `hs` is needed.
* **MILESTONE: the `l = −1` slice of (8.8.41) at `0 ≤ ⟨a,b⟩` is UNCONDITIONAL at FLM's datum**:
  `negOneFaceAligned_evenCocycle (C) (h2) (hs) : NegOneFaceAligned (C.toCentralExtension h2)` — batch
  188-A's residual is now a **theorem**.  For an arbitrary landed `CentralExtension` the transport needs
  `CocycleCompatible` (`negOneFaceAligned_of_cocycleCompatible`).
* **Route**: the landed (8.4.25) expansion `YFam_mul_apply_eq_sum_ratioCoeff` + **the landed (8.4.20)
  `MM.FLM86AR.assemblyDiagonal`** (read as `assemblyDiagonal_antidiagonal`) + a new
  `sum_range_ratioCoeff : Σ_{j≤N} ratioCoeff N j = (1−1)^N`.
* **Correction of record**: batch 188-A's "the cross side is the single-order diagonal of `(∗)`" is
  **false in general** — `crossTermSwap` is the opposite order (the antisymmetrisation of (8.8.13)), and
  the two orders differ by the constant `1 − c(b,a)(−1)^{⟨a,b⟩}` (the landed (8.4.41)); so the transport
  to the single-order form holds exactly under `CocycleCompatible` (true at the even cocycle), and the
  converse is open.  Also recorded: `rwa` inside the big cross-bracket context exceeded 1.6M heartbeats
  (use `rw … at h; exact h`), and the two `ZAligned` copies must not be mixed.

**B189-B ACCEPTED — `Definitions/MMFLM86BlockSecondLayer.lean` (287 lines),
`MMFLM86BlockDerivRegrouped.lean` (223 lines), `MMFLM86NegTwoAssembly.lean` (336 lines)** (namespaces
`MM.FLM86BSL`/`MM.FLM86BDR`/`MM.FLM86NTA`; 16 guards, all exactly the three-axiom set).

* **THE ORDERING QUESTION IS SETTLED, AND THE PREMISE REFUTED**: the three-piece split is **not** buggy.
  `firstDeriv = d/dz₁` differentiates only the first slot, so the "other orderings" are the `d/dz₂`
  halves — a different operator — and must not be added.  Landed:
  `flatMul_deriv_creationExpVL_half` (`flatMul (dE⁻_a)(E⁻_b)` is the **whole** `a(z)⁻` half, not "half
  of `dE⁻_{a+b}`"), `flatMul_deriv_annihIdx_half` (the whole `a(w)⁺` half), and
  `deriv_creationExpVL_eq_halves`.  So the three pieces carry exactly the `a(z)⁻`, `a(0)`, `a(z)⁺`
  terms of `:a(z)Y(ab,z):`.  **The batch-187-B header sentence "the other half is what the mirror piece
  has to produce" is FALSE** (to be corrected in the next dispatcher edit).
* **The block's second layer is landed**: `sum_firstDeriv_midBlock2_fiber` — the fibre at degree `K'`
  collapses to `ε(a,b)·(actVL (a+b) · (hZeroVL (ofLattice a) · z^{(a+b)(0)}_{K'+1}))u` (note the **index
  shift** `K' ↦ K'+1`), with the per-state window lemmas
  `exists_midGradDeriv_antidiagonal`/`exists_midGradDerivVL_antidiagonal` and
  `diagSum_blockDerivPiece_regrouped` (the third piece in the `(J,K')` normal form).
* **The exact residual is now `NegTwoNormalFormLine`** — all three Leibniz pieces in the collapsed
  normal form, block second layer included — with **both directions**
  (`annihClosed_iff_normalForm`, `NegTwoFirstDerivZero ↔ NegTwoNormalFormLine`,
  `NegTwoExactResidualAligned (C.toCentralExtension h2) ↔ NegTwoNormalFormLine`).  **The remaining gap is
  not an ordering but the (8.4.23) dictionary `Y(a(−1)u,z) = 8a(z)Y(u,z)8` at the aligned boundary
  field.**  Also recorded: `a(0)` must be `hZeroVL (ofLattice a)` — `modeVL a 0 = 0` in this pin.

**Where Theorem 8.10.2 stands at the end of batch 189.**  Unconditional at FLM's datum: the `l = 0` face
for `0 ≤ ⟨a,b⟩` and `⟨a,b⟩ = −1`; the whole `l ≥ 0` chamber at `0 ≤ ⟨a,b⟩`; and now the `l = −1` slice.
Open: the `−2` case (the (8.4.23) dictionary), the `≤ −3` case, the Fock half, the `l ≤ −2` faces, the
continuation to full Jacobi, and the six boundary inputs.  **Batch 190**: (A) the (8.4.23) dictionary
`Y(a(−1)u,z) = 8a(z)Y(u,z)8` at the aligned field — which closes `NegTwoNormalFormLine` if it lands;
(B) the general `l ≤ −2` faces.

**Brief errors this batch**: the "missing ordering"/statement-bug premise (refuted); the "cross side =
single-order diagonal" claim (needs `CocycleCompatible`); the `a(0)` reading (`modeVL a 0 = 0`); and the
chamber-2 input (the full `assemblyDiagonal`, not just `middleBlockDiagonal`).

---

### Batch 190 — the `l = −2` face's `1 ≤ ⟨a,b⟩` chamber is UNCONDITIONAL at FLM's datum; the `(8.4.23)` dictionary is landed (and the `−2` gap is relocated to the FLAT REASSEMBLY); the moment hierarchy is measured

Three new files, two fresh agents, one batch; all verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B190-B ACCEPTED — `Definitions/MMFLM810NegTwoFace.lean` (479 lines) and
`MMFLM810NegTwoChambers.lean` (571 lines)** (namespaces `MM.FLM810NTF`/`MM.FLM810NTC`; 10 guards, all
exactly the three-axiom set).

* **LANDED, unconditional at FLM's datum**: `negTwoFaceAlignedOneLe_evenCocycle` — the `1 ≤ ⟨a,b⟩`
  chamber of the `l = −2` slice of (8.8.41), **per element**, at every past-vanishing window `N ≥ 2`,
  with both sides evaluated (`ε(a,b)·YFam (a+b) (m+n)` at `⟨a,b⟩ = 1`, `0` for `⟨a,b⟩ ≥ 2`).
  Supporting: `deltaExpCoeff i (−2) = i + 1`, the exact cross side, the two-term iterate collapse **for a
  general `E`**, the three chamber values of `iterateOf (−2)`, (8.10.5) termination, and the new
  first-moment identity `Σ_j j·ratioCoeff N j = −1` at `N = 1` and `0` for `N ≥ 2`.
* **The `⟨a,b⟩ = 0` chamber** is equivalent to `WeightedZOneLineZeroPairing E` — the `z_0^1` line of
  (8.4.36)/(8.4.40) **at pairing-zero pairs**, the *same* identity as the landed
  `MM.FLM86NTD.ZOneLineNegTwo`/`NegTwoDiagonalWeight` (stated at pairing `−2`) — and that **iff
  (`negTwoFaceAligned_iff_weightedZOneLine`) is the one brief item not landed** (budget ran out; all its
  ingredients are in the companion).  **So the `z_0^1` line is now the shared blocker of both the
  `l = 0`, `⟨a,b⟩ = −2` case and the `l = −2`, `⟨a,b⟩ = 0` chamber.**
* **General `l ≤ −2` measured**: the cross side reindexes to a **weighted** antidiagonal with weight
  `ratioCoeff l (m+l−p)`, a degree `L − 1 = −l − 1` polynomial in `p`; `L = 1` needs no moment, `L = 2`
  only the first (killed by `Σ_j ratioCoeff = 0` — *why `l = −2` lands*), and `L ≥ 3` needs the
  **moment hierarchy** `Σ_r r^m · normOrdered2 a b r (K−r) = 0` for `m + 1 ≤ ⟨a,b⟩` (the `m`-th
  derivative of (8.4.40)) — **not landed**; the iterate side needs the Fock-descendant evaluations.
* Corrections: `MM.FLM810JNF/NOF/NOC` are namespaces, not files; at `⟨a,b⟩ = 0` the `l = −2` iterate side
  is **not** closed form (it carries the Fock descendant `ZAligned E (creationExpVL a 1 (anchorVL E a b))`
  — the same open line); and the `l = −2` cross side is **weighted**, so `diagSum_honestDiag_eq` does not
  apply (the two half-lines' union misses `p = m−1`, where the weight vanishes).

**B190-A ACCEPTED — `Definitions/MMFLM86DerivDictionary.lean`** (437 lines, namespace `MM.FLM86DD`,
21 guards, all exactly the three-axiom set).

* **The (8.4.23) dictionary is landed** — and the inventory showed it was **already there at an arbitrary
  vector and base** (`MM.FLM810CI.Yzero_modeVL_eq_actionFamily(_nat)`,
  `MM.FLM85PC.ZAligned_creationStep`, `MM.FLM86NTR.coherentField_one`), together with its `L(−1)`
  companion `BaseResidual (baseAligned E)` (`MM.FLM85PC2.baseResidual_baseAligned_of_symm`, batch 172).
  New: the aligned-field forms (`ZAligned_modeVL_neg_one` general `u`, `ZAligned_creationExpVL_one`, the
  (8.5.4)-state and lattice forms, the `L(−1)` companion), the factor-level facts
  (`factorFactorZero_one_fam`, `splitMinus_factorFactorZero_one_zero = a(−1)`,
  `splitPlus_factorFactorZero_one_neg_one = hZeroVL (ofLattice a) = a(0)`,
  `headOp_factorFactorZero_one_ne_flatMul`), and `ZAligned_creationExpVL_one_anchor` — which kills
  `anchorVL`/`ZAligned`/`Yzero` from the residual's right-hand side.
* **The `−2` gap is RELOCATED to the flat reassembly**: the residual is now `DerivDictionaryLine`
  (defined, **both directions** to `NegTwoFirstDerivZero`/`NegTwoNormalFormLine`/
  `NegTwoExactResidualAligned`): matching the three collapsed flat sums with
  `headOp (heisFamZero a) + tailOp` of `Y(a+b,z)` ((8.4.36)/(8.4.40) at `z_0^1`).  Measured: the creation
  half is already in `flatMul (splitMinus (heisFam a)) (creationExpVL (a+b))` shape; the `a(0)` summand
  belongs to the tail and the negative `mid`-degrees must be carried by the free `(J,K')` windows.
* Correction of record: `BaseResidual`/`generalStateDeriv` is **not** (8.4.23) in disguise — it is its
  derivative/`L(−1)` companion at `u = ι(a)`, and it is a **theorem** at the aligned base.

**Where Theorem 8.10.2 stands at the end of batch 190.**  Unconditional at FLM's datum: the `l = 0` face
for `0 ≤ ⟨a,b⟩` and `⟨a,b⟩ = −1`; the `l ≥ 0` chamber at `0 ≤ ⟨a,b⟩`; the `l = −1` slice; and now the
`l = −2` face's `1 ≤ ⟨a,b⟩` chamber.  **The single shared open object** is the `z_0^1` line
(`DerivDictionaryLine` = `ZOneLineNegTwo` = `WeightedZOneLineZeroPairing`): the flat reassembly /
(8.4.36) at `z_0^1`.  **Batch 191**: (A) the `⟨a,b⟩ = 0` equivalence plus the `z_0^1` line's flat
reassembly; (B) the moment hierarchy for `l ≤ −3`.

**Brief errors this batch**: namespaces vs files; "the iterate side is already computed" (false at
`⟨a,b⟩ = 0`); "two diagonal sums of the `(∗)` shape" for the weighted `l = −2` cross side; and the
(8.4.23) premise (it was already landed).

---

### Batch 191 — the `z_0^1` line's missing half is DIAGNOSED (the (8.4.19) tail contraction) and unified as `ZOneLineAllPairings`; the moment picture is CORRECTED (only the low moments survive; `N ≥ c` gives 0) and the `l = −3`, `2 ≤ ⟨a,b⟩` chamber is closed by the landed assembly

Two new files, two fresh agents, one batch; both verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B191-A ACCEPTED — `Definitions/MMFLM86ZOneReassembly.lean`** (458 lines, namespace `MM.FLM86ZOR`,
10 guards, all exactly the three-axiom set).

* **The reassembly is NOT landed; its missing half is diagnosed**: the creation half is already in
  `flatMul (splitMinus (heisFam a)) (creationExpVL (a+b))` shape and the `a(0)` summand does belong in the
  tail, but placing it there requires **carrying `a(k)` (`k ≥ 0`) past `E^+_{a+b}` through the (8.4.19)
  contraction inside the free `(J,K')` windows** — no landed theorem performs that (only the per-half
  collapses exist).  Step-1 grep was measured **negative** (no landed reassembly).
* **The equivalence is landed**: `negTwoFaceAligned_iff_weightedZOneLine (C) (h2) (hs)`, both directions,
  via `zeroPairing_iff_weightedZOneLine` (under `CocycleCompatible`),
  `weightedHonestDiag_zero_eq_diagSumWeighted` (the `p ↦ −p−1` reindexing of the two half-lines at
  `⟨a,b⟩ = 0`, using `YFam_mul_eq_normOrdered2_of_form_eq_zero`) and `negTwoZeroWindow_weighted_eq_zero`
  (the weight `p+m` vanishes off the reindexed window; the gap `p = −m` is exactly the zero-weight point).
* **Correction of record**: `DerivDictionaryLine` (at `⟨a,b⟩ = −2`) does **not** imply
  `WeightedZOneLineZeroPairing` (at `⟨a,b⟩ = 0`) — the pairing is not a variable of either statement.
  The **unified** obligation is the new `MM.FLM86ZOR.ZOneLineAllPairings` (**the `z_0^1` line for ALL
  pairs**), and the file lands `zOneLineNegTwo_of_allPairings`, `weightedZOneLine_of_allPairings`,
  `derivDictionaryLine_of_allPairings`.  **So the single remaining obligation for both faces is the tail
  contraction making `ZOneLineAllPairings` a theorem.**
* Also recorded: `MM.FLM810NTF.negTwoFaceAligned_iff_weightedZOneLine` did **not** exist anywhere (only
  prose mentions it); it is now landed under `MM.FLM86ZOR`.

**B191-B ACCEPTED — `Definitions/MMFLM86MomentHierarchy.lean`** (491 lines, namespace `MM.FLM86MH`,
6 guards, all exactly the three-axiom set).

* **THE MOMENT PICTURE IS CORRECTED** (the batch-190-B measurement was wrong): the moments
  `Σ_r r^m · normOrdered2 a b r (K−r)` do **not** vanish for `m+1 ≤ ⟨a,b⟩`; `m = 0` is the assembly,
  `m = 1` the `z_0^1` line.  Correct: expanding by (8.4.25) and regrouping makes the `j`-sum produce the
  finite-difference sum `Σ_j ratioCoeff N j · (poly in j)`, and by
  `Σ_j ratioCoeff N j j^s = 0` for `s < N` **only the LOW moments `m ≤ c−1−N` survive**.
* Landed: `ratioCoeffSum_eq_binomCoeffFinDiff` (consuming the already-landed
  `MM.FLM86Y.binomCoeffFinDiff` core from `MMFLM86TaylorOperatorAux.lean` — the first draft re-proved an
  equivalent before finding it), the **new** vanishing case `binomCoeffFinDiff_eq_zero_of_lt` (`s < n`,
  not covered by the landed `n ≤ s` lemma), `binomCoeffFinDiff_eq_int`,
  `deltaExpCoeff_neg_eq_binomCoeff` (the `l = −c` weight is `C(m−p−1, c−1)`), the **master identity**
  `weightedHonestDiag_eq_sum_ratioCoeff`, and its specialisations: `weightedHonestDiag_eq_binomMoment`
  (`N ≤ c−1`), **`weightedHonestDiag_eq_zero_of_le` (`N ≥ c`: the weighted antidiagonal is 0 — no
  moment, no (8.4.40) line, no new residual)**, `weightedHonestDiag_eq_assembly` (`N = c−1`, the landed
  `assemblyDiagonal`), `weightedHonestDiag_eq_firstMoment` (`N = c−2`, the `z_0^1` line), and
  `negThree_weightedChambers` (**the `l = −3`, `2 ≤ ⟨a,b⟩` chamber: `ε(a,b)·YFam (a+b) (m+n)` at
  `⟨a,b⟩ = 2`, `0` for `⟨a,b⟩ ≥ 3` — closed by the landed assembly alone**).
* **Corrections**: the moment hierarchy as stated in the brief is false; `l = −3` with `2 ≤ ⟨a,b⟩` needs
  no hierarchy; and the `l = −3`, `⟨a,b⟩ = 1` chamber is **not** reachable today (it needs the `z_0^1`
  line at pairing 1, which is neither of the two named residuals).
* **The `l = −3` residual** (recommended next): (a) the general-`c` cross-side reindexing (mechanical,
  via `deltaExpCoeff_neg_eq_binomCoeff` + the reflection `C(−i−1, c−1) = (−1)^{c−1}C(i+c−1, c−1)`);
  (b) the `l = −c` analogue of `honestDiag_eq_zero_of_crossWindowOn`; (c) the iterate side at `l = −3`.

**Where Theorem 8.10.2 stands at the end of batch 191.**  Unconditional at FLM's datum: `l = 0`
(`0 ≤ ⟨a,b⟩`, `⟨a,b⟩ = −1`), `l ≥ 0` (`0 ≤ ⟨a,b⟩`), `l = −1`, `l = −2`'s `1 ≤ ⟨a,b⟩` chamber, and
`l = −3`'s `2 ≤ ⟨a,b⟩` chamber.  **The single shared obligation is `ZOneLineAllPairings`** (the `z_0^1`
line for all pairs), whose missing half is the (8.4.19) tail contraction.  **Batch 192**: (A) that tail
contraction; (B) the `l = −3` face's mechanical parts (a)--(c).

**Brief errors this batch**: "the ingredients, all landed" (the tail contraction was missing); "the
reassembly closes both faces at once" (needs the unified all-pairings statement); and the moment-hierarchy
claim (refuted; the corrected picture is the finite-difference sum).

---

### Batch 192 — the `l = −3` face at `2 ≤ ⟨a,b⟩` is UNCONDITIONAL at FLM's datum; the `(8.4.19)` premise is corrected (the contraction is against `E⁻`, not `E⁺`) and the annihilation/zero-mode laws are landed

Two new files, two fresh agents, one batch; both verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B192-B ACCEPTED — `Definitions/MMFLM810NegThreeFace.lean`** (630 lines, namespace `MM.FLM810NTH`,
6 guards, all exactly the three-axiom set).

* **`negThreeFaceAlignedTwoLe_evenCocycle (C) (h2) (hs)`** — the `l = −3` face of (8.8.41) at
  `2 ≤ ⟨a,b⟩`, per element, per monomial, every window `N ≥ 3`, **unconditional at FLM's own datum**
  `C.toCentralExtension h2`.  Pairings `1` and `0` are not claimed.
* Supporting, all **general `c ≥ 1`** where possible:
  **(a)** `crossBracket_neg_nat_eq_sum` (under `CocycleCompatible`): the cross side is a weighted sum
  `Σ_p binomCoeff (m−p−1) (c−1) • honestDiag E a b p (m+n−c−p) w` over the two half-lines, with the
  reflection `binomCoeff_pos_eq_neg_pow` (from `FLM810SJ.binomCoeff_neg_succ_eq`) and
  `disjoint_negCWindows`;
  **(b)** `weightedHonestDiag_eq_zero_of_crossWindowOn` (general `c`): the face's own `CrossWindowOn` gives
  the **weighted** vanishing outside the half-lines (weight `0` in the gap `m−c < p < m`, while the honest
  diag is *not* zero there), plus the window-independence bridge `weightedHonestDiag_neg_three_eq`;
  **(c)** `crossIterate_ZAligned_lattice_neg_three` (general `E`): `i = 0,1,2` survive, with the chamber
  forms giving `ε(a,b)·YFam (a+b) (m+n)` at pairing `2` and `0` above.
* **Correction**: the brief's "(b) turns `CrossWindowOn` into the *honest* vanishing" is wrong — it yields
  the **weighted** vanishing, and the face additionally needs the window-independence bridge (landed).

**B192-A ACCEPTED — `Definitions/MMFLM86TailContraction.lean`** (641 lines, namespace `MM.FLM86TC2`,
17 guards, all exactly the three-axiom set).

* **`(8.4.19)` read verbatim off printed p. 192** (PDF index 246):
  `8α(z)Y(a,z)8 = 8Y(a,z)α(z)8 = α(z)⁻Y(a,z) + Y(a,z)α(z)⁺`, with (8.4.10)'s `α(z)^±` splitting.
* **THE PREMISE OF BATCH 191 IS REFUTED, and it is good news**: **there is no contraction past `E⁺`** for
  any `k ≥ 0` (`k ≥ 1` was already landed as `MM.FLM86TN.modeVL_comm_annihExp_pos`; `k = 0` is proved here:
  `hZeroVL_comm_annihExp`, `splitPlus_heisFamZero_comm_annihExp`).  The contraction (the `⟨a,b⟩` shift)
  lives against `E⁻` and was already landed (`MM.FLM84CT.modeVL_comm_creationExpVL_int`,
  `hZeroVL_comm_creationExpVL`); it is repackaged here as
  `splitPlus_heisFamZero_contraction_creation`.  What was genuinely missing at the **assembled** field was
  the **annihilation/zero-mode** law, now landed: `modeVL_YFam_add_pos`, `hZeroVL_YFam_add` (the zero mode
  differentiates the middle factor by the pairing), and the uniform
  **`splitPlus_heisFamZero_YFam_add : a(k)(Y(a,z)_j v) = Y(a,z)_j (a(k) v) + ⟨b,a⟩ Y(a,z)_{j+k} v`** for all
  `k ≥ 0`.
* Also landed: `ZAligned_anchor_head_tail` (the residual's right-hand side in the corrected
  `FLM85TA.headOp` + `FLM85Ac.tailOp` spelling) and **`zOneLineAllPairings_iff_headTail`**
  (`ZOneLineAllPairings` ⟺ that spelling, **both directions**, no weakening).
* **`ZOneLineAllPairings` is still the named residual**; what remains is the **flat reassembly** (the
  (8.10.8)-associativity step), named under the equivalent `DerivDictionaryLine`/`NegTwoNormalFormLine`/
  `NegTwoFirstDerivZero`/`ZOneLineNegTwo`.  Conditional on it, **both faces now close** by new
  compositions: `negTwoFirstDerivZero_of_allPairings`, `negTwoExactResidualAligned_of_allPairings`
  (`l = 0`, `⟨a,b⟩ = −2`) and `negTwoFaceAlignedZeroPairing_of_allPairings` (`l = −2`, `⟨a,b⟩ = 0`).
* Traps recorded: `headOp` must be `FLM85TA.headOp` (not `FLM85Ac.headOp`); `factorFactorZero` lives in
  `FLM810ZM`; `sub_eq_iff_eq_add'` (not `.mp`); on `Module.End` the `Sub`/`Add` diamond defeats
  `sub_eq_zero`/`sub_self`/`simp` (work at the vector level); repeated `rw` of one lemma errors on the
  second pass (`simp only` is the fix).

**Where Theorem 8.10.2 stands at the end of batch 192.**  Unconditional at FLM's datum: `l = 0`
(`0 ≤ ⟨a,b⟩`, `= −1`), `l ≥ 0` (`0 ≤ ⟨a,b⟩`), `l = −1`, `l = −2`'s `1 ≤ ⟨a,b⟩` chamber, and now
**`l = −3`'s `2 ≤ ⟨a,b⟩` chamber**.  **The single shared obligation is the flat reassembly**
(`ZOneLineAllPairings` ⟺ its head/tail spelling), which closes both the `l = 0`, `⟨a,b⟩ = −2` case and
the `l = −2`, `⟨a,b⟩ = 0` chamber.  **Batch 193**: (A) the flat reassembly, now with
`splitPlus_heisFamZero_YFam_add` in hand; (B) general `l ≤ −4` (the `l = −3` template + the moment
machinery).

**Brief errors this batch**: the `E⁺`-contraction premise (refuted; it is against `E⁻`); "honest
vanishing" for the window lemma (it is weighted); and the `headOp`/`factorFactorZero` locations.

---

### Batch 193 — general `l = −c`: the `ν ≥ c−1` chamber is UNCONDITIONAL for every `c`; and the `z_0^1` residual is landed ON THE LATTICE GENERATORS and proved F-LINEAR in the state (the Fock half is the only input left)

Two new files, two fresh agents, one batch; both verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B193-B ACCEPTED — `Definitions/MMFLM810NegCFace.lean`** (583 lines, namespace `MM.FLM810NCF`,
12 guards, all exactly the three-axiom set).

* **`negCFaceAlignedGe_evenCocycle (C) (h2) (hs) {c} (hc : 1 ≤ c)`** — the general `l = −c` face of
  (8.8.41) at `ν := (form a b).toNat ≥ c − 1`, **unconditional at FLM's datum**, per element, for **every**
  `c ≥ 1`.  Supporting: `negC_weightedChambers` (assembly at `ν = c−1`, `0` for `ν ≥ c`),
  `crossBracket_ZAligned_lattice_neg_nat_eq_ite`, and the **general-`E`** iterate side
  `crossIterate_ZAligned_lattice_neg_nat` (+ `…_eq_sum_succ` for `ν ≤ c−2`: `k = c−1−ν` Fock descendants
  plus the boundary value), with `crossWindowOn_ZAligned_lattice_neg_nat`.
* **Exact residual `NegCBinomMomentAligned E c`** (the binomial-moment identity for `0 ≤ ν ≤ c−2`), with
  `negCFaceAligned_iff_binomMoment_evenCocycle` **both directions**.  Chambers: `ν ≥ c−1` unconditional;
  `ν = c−2` is the **first moment (`z_0^1` line)**, `1 ≤ ν ≤ c−3` the `z_0^{c−1−ν}` lines, `ν = 0` the
  `z_0^{c−1}` line.  So **`c = 1` is entirely unconditional** (the landed `−1` face), `c = 2` leaves only
  `ν = 0` (the landed `WeightedZOneLineZeroPairing`), `c = 3` leaves `ν ∈ {0,1}`.
* Corrections: `crossIterate_…_of_nonpos` was stated only at the even-cocycle datum (restated at general
  `E`; it also pins `N ≥ c`); the residual range is `0 ≤ ν ≤ c−2` (not `1 ≤ N ≤ c−3`); the iterate side
  needs pointwise state vanishing (not just `iterateOf_eq_zero`); and two cast/defeq traps.

**B193-A ACCEPTED — `Definitions/MMFLM86FlatReassembly.lean`** (579 lines, namespace `MM.FLM86FRA`,
8 guards, all exactly the three-axiom set).

* **LANDED: the `z_0^1` residual holds ON THE LATTICE GENERATORS, for ALL pairings**:
  `zOneLineAllPairingsOnGenerators (hs) (E)` — for all `a b m n c` there is a window with
  `Σ_{p∈s} p • normOrdered2 a b p (−m−n−p) (ι c) = ZAligned E (creationExpVL a 1 (anchorVL E a b)) (m+n) (ι c)`.
  Supporting (all new): `genFam_iotaVL`, `modeVL_iotaVL_eq_zero_of_pos`, and the index bridges
  `sum_Icc_eq_flatMul`, `sum_Icc_smul_eq_flatMul_deriv` (**the weight `p` IS the (8.4.12) derivative**),
  `sum_range_toNat_succ_eq_flatMul`.
* **LANDED: the residual is `F`-LINEAR in the state** — `ZOneLineAt` (at one pair/monomial/state),
  `zOneLineAllPairings_iff_forall_ZOneLineAt` (`Iff.rfl`), and `zOneLineAt_add`, `_smul`, `_zero`,
  `_of_mem_span`.  **So `ZOneLineAllPairings` is determined by its values on any spanning set of `V_L`;
  with the generator half, the only remaining input is the residual on the creation monomials
  `α₁(−n₁)…α_k(−n_k) ι(c)` — the Fock half.**
* **Corrections**: `splitPlus_heisFamZero_YFam_add` was **not** the missing tool (in the head/tail spelling
  the `a(k)` summands *already are* the tail; the generator case consumes only the landed fact that the
  tail's `k = 0` summand is the zero mode); the reassembly is **not** a reindexing inside the `(J,K')`
  windows (those belong to the `z_0^0`/firstDeriv line) — at an arbitrary state the flat pieces reach the
  action only through the **annihilation-pair contractions**, i.e. the Fock half, a (8.10.8)-associativity
  computation; and the `⟨a,b⟩ = −2` instance does not imply the general-state identity.

**Where Theorem 8.10.2 stands at the end of batch 193.**  Unconditional at FLM's datum: `l = 0`
(`0 ≤ ⟨a,b⟩`, `= −1`), `l ≥ 0` (`0 ≤ ⟨a,b⟩`), `l = −1`, and — for **every** `c ≥ 1` — the `ν ≥ c−1`
chamber of the `l = −c` face (which subsumes the earlier `l = −2`, `−3` chamber results).  **The single
shared obligation is the `z_0^1` line `ZOneLineAllPairings`, now reduced to its Fock half** (it holds on
the generators and is linear in the state).  **Batch 194**: (A) the residual at the first Fock level
`α(−n)ι(c)` (the `E⁺_aE⁺_b` contraction past one creation mode, with the landed
`MM.FLM810CFC.modeVL_mul_annihExp_sub`/`modeVL_annihFam_add` as the engine); (B) the higher `z_0^m` lines
(`m ≥ 2`, the `1 ≤ ν ≤ c−3` chambers) by the (8.4.40) chain.

**Brief errors this batch**: the `E⁺`-contraction framing; the residual range; the `crossIterate` generality;
and the claim that the flat reassembly is a window bookkeeping step.

---

### Batch 194 — the `z_0^1` line at the FIRST FOCK LEVEL is LANDED (with the contraction and the right-hand-side mode law); and the derivative ladder shows NO higher `z_0^k` line is easier than the `z_0^1` blocker

Two new files, two fresh agents, one batch; both verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B194-A ACCEPTED — `Definitions/MMFLM86ZOneFockOne.lean`** (954/960 lines, namespace `MM.FLM86ZOF`,
14 guards, all exactly the three-axiom set).

* **LANDED, unconditional apart from the form symmetry `hs`**:
  **`zOneLineAt_modeVL_iotaVL`** — the `z_0^1` residual `MM.FLM86FRA.ZOneLineAt` at
  `v = α_{c'}(−R) ι(c)`, **every pairing, every `R ≥ 1`, every `(m,n)`**.  This is the first Fock level of
  the shared blocker.
* Engine landed alongside: **the contraction `normOrdered2_modeVL_sub`**
  (`normOrdered2 a b p q (α_c(−r)w) = α_c(−r)(normOrdered2 p q w) − ⟨c,a⟩·normOrdered2 (p+r) q w −
  ⟨c,b⟩·normOrdered2 p (q+r) w`, shift `+r` in **both** indices), whose direction was forced by
  consistency of the two laws (a priori `−r` was possible); its weighted-diagonal corollary
  `diagSumWeighted_modeVL`; **the right-hand-side mode law `ZAligned_modeVL`**
  (`Z_j(α_c(−r)w) = α_c(−r)(Z_j w) − ⟨c,a+b⟩·Z_{j−r}w + ε(a,b)·r·⟨a,c⟩·Y(a+b,z)_{r−j}w`); the window laws
  `headWindow_modeVL_shift`/`tailWindow_modeVL_shift`; and the generator collapse
  `diagSum_normOrdered2_iotaVL`.
* **The general creation monomial is NOT reached, and the reason is precise**: the single-mode proof closes
  because the contraction reduces both sides to the **two landed generator cases** (degrees `−m−n` and
  `−m−n+R`) plus the generator collapse; at the **next** mode the contraction produces the **unweighted
  diagonal sum at the level-one descendant `α_{c''}(−R₂)ι(c)`** — i.e. the **`z_0^0` line at a Fock
  descendant**, genuine new input, not a corollary of the generator case.  **The exact remaining
  sub-residual is that descended `z_0^0` line.**
* **Corrections**: the named engine `modeVL_mul_annihExp_sub`/`modeVL_annihFam_add` covers only the
  **left**-hand side (the right needs `ZAligned_modeVL`); the landed `headWindow_modeVL_sub`/
  `tailWindow_modeVL_sub` **cannot** be used as stated (they force the field's lattice label to equal the
  factor's, while the residual has field `Y(a+b,z)` and factor `a(z)`); and the shift direction (`+r` in
  both laws) was unstated.  Traps: `-r • x` parses as `(-r)•x` but prints like `-(r•x)`; `rw` instantiates
  a lemma **once per pass**, so repeating a name silently rewrites only the first instantiation (no error);
  the `-γ•H` vs `-(γ•H)` mismatch needs explicit `calc`/`show`.

**B194-B ACCEPTED — `Definitions/MMFLM86ZMoments.lean`** (650 lines, namespace `MM.FLM86ZM`, 12 guards,
all exactly the three-axiom set).

* **NO higher `z_0^k` line is easier than the `z_0^1` blocker**: the landed **derivative ladder**
  `momentSum_firstDeriv` / `zLineAt_firstDeriv` / **`zLineScheme_succ_firstDeriv`** is an
  **equivalence** — the `(j+1)`-st line of `X` at degree `K+1` (value `R`) ⟺ the `j`-th line of
  `d/dz₁X` at degree `K` (value `(j+1)·R`).  Hence order `k` **is** order 0 (assembly-shaped) of
  `firstDeriv^k (normOrdered2 a b)` — the derivative tower of the shared blocker, exactly batch 185's
  measurement at `j = 1`.
* Also landed: the Vandermonde expansion `binomCoeff_add_eq_sum` (and `binomCoeff_add_two` — "the
  quadratic weight expanded flat") and the flat reassembly `sum_binomCoeff_smul_eq_sum`.
* **The exact residual `ZLine E j`** (pairing-free, at the boundary field): `j = 0` is a **theorem**
  (`zLine_zero`, the landed (8.4.20) assembly), **`j = 1` is verbatim the shared blocker**
  (`zLine_one_iff_zOneLineAllPairings`, both directions), `j ≥ 2` is the new residual.
* **The chamber decomposition of `NegCBinomMomentAligned E c`**: `NegCMomentLine E c k := ZLine E k`
  restricted to pairings `N = c−1−k`; forward, each chamber consumes exactly its own line; backward,
  `negCBinomMomentAligned_of_zLine` (all lines `1 ≤ j ≤ c−1` suffice).  **Ledger**: `N ≥ c` zero; `N = c−1`
  the landed assembly; `N ≤ c−2` the `c−1` residual chambers, **all of the `z_0^k` form with
  `k = c−1−N`** — so every remaining chamber is decided by the same derivative tower, and none is closed
  by this batch.  Edge case `c = 1`: residual empty.
* Correction: the landed `z_0^2` statements are for the **one-variable** `openBoxField`/formal
  `shiftFamily`, not the honest three-factor `normOrdered2 a b` (and the `MMFLM86*` ones are conditional on
  the named gap `Shifted8436`/`SubstProductExpansion`); and the `ν = c−3` chamber needs Vandermonde's
  orders 0,1,2, not just `z_0^2`.

**Where Theorem 8.10.2 stands at the end of batch 194.**  The single shared obligation is still the
`z_0^1` line `ZOneLineAllPairings`, now known to be: **proved on the generators** (batch 193-A),
**`F`-linear in the state** (193-A), **proved at the first Fock level** (194-A), and **the easiest of all
the `z_0^k` lines** (194-B's derivative ladder).  The next input is the **descended `z_0^0` line**
(`α_{c''}(−R₂)ι(c)`).  **Batch 195**: (A) that descended assembly identity; (B) the general
creation-monomial induction (level `n` → `n+1`) for both lines together.

**Brief errors this batch**: the engine covers only the LHS; the `headWindow_modeVL_sub` reuse claim; the
shift direction; the "induction on the (8.5.4) list" understatement; and the `z_0^2` "already landed"
hint (wrong shape, one-variable).

---

### Batch 195 — 🎉 BREAKTHROUGH: the shared obligation `ZOneLineAllPairings` IS A THEOREM (the `z_0^1` line of (8.4.36)/(8.4.40) for all symmetric pairings); and the earlier "descended `z_0^0` line" premise is REFUTED

Two new files, two fresh agents, one batch; both verified here (rebuild from deleted `.olean`s,
`--- OK ---` for each, `Probe/forbidden_tokens.py` at zero, the in-file `#guard_msgs`, and the
`FinalCheck.lean` acceptance build after wiring them in).

**B195-B ACCEPTED — `Definitions/MMFLM86FockInduction.lean`** (348 lines, namespace `MM.FLM86FI`,
10 guards, all exactly the three-axiom set).  **This closes the campaign's single shared obligation.**

* **`zOneLineAllPairings_of_symmetric_form (hs) (E) : MM.FLM86ZOR.ZOneLineAllPairings bL form E` — a
  THEOREM**, from landed ingredients only.  The `z_0^1` line of (8.4.36)/(8.4.40) now holds at every
  **symmetric** pairing, with **no residual left**.  (Honest caveat, recorded in the file:
  `ZOneLineAllPairings` is *defined* without `hs`; only its symmetric-form instance is proved, which is
  the hypothesis of every landed ingredient and consumer — FLM (7.2.22)/(7.2.23).)
* **The induction chain**: `zOneLineAtLevel_zero` (the batch-193-A generator case) →
  **`zOneLineAt_modeVL`** (the step: weigh the level-`n` hypotheses at `(m,n)` and `(m−r,n)` against the
  **landed assembly** at `w` at degree `−m−n+r`, with the window
  `U = (s₁∪s₂∪s₃) ∪ (s₁∪s₂∪s₃)−r`, then `diagSumWeighted_modeVL` + `ZAligned_modeVL`) →
  `zOneLineAtLevel_succ` → `zOneLineAtLevel_all` (`Nat.rec`) → `zOneLineAllPairings_of_level`
  (`zOneLineAt_of_mem_span` + `spanningStatement`).
* **HEADLINE CORRECTION: the "descended `z_0^0` line" does NOT exist as new input.**  The landed
  `MM.FLM86AR.assemblyDiagonal` / `MM.FLM810NOC.assemblyDiagonal_antidiagonal` (batch 181) already proves
  the unweighted diagonal sum at **every state and every pairing** with the per-state (8.10.5) window;
  batch 194-A's `diagSum_normOrdered2_iotaVL` is that value law at `w = ι(c)`.  Hence
  `zZeroLineAtLevel_all : ∀ n, ZZeroLineAtLevel E n` needs no induction, and the level-`n` hypothesis
  carries the `z_0^1` half **only**.  The batch-195-A task (dispatched on the refuted premise) was
  **steered mid-flight and stopped**.
* Minor window correction: the step needs the **`−r`-shift of the assembly window** (`s₃ − r ∈ U`);
  batch 194-A's level-one proof could omit it only because at a generator every vanishing window gives the
  same sum.

**B195-A ACCEPTED (minor) — `Definitions/MMFLM86DescendedAssembly.lean`** (370 lines, 9 guards, all
exactly the three-axiom set).  With the headline refuted, the file's only non-redundant content is the
**window-level decomposition** `diagSum_normOrdered2_modeVL_of_lines` (exactly which windows the
contraction consumes: `(K,W)`, `(K+r,W)`, `(K+r,W+r)`), the **hypothesis-free explicit window**
`diagSum_normOrdered2_modeVL_iotaVL` (`Icc (⟨a,c⟩−r) (K+r−⟨b,c⟩)`) and the vanishing lemma
`normOrdered2_modeVL_iotaVL_eq_of_support`.  It adds **no new value law**; kept for the window bookkeeping
and the explicit witness.

**Consequences now available for free** (the landed one-directional reductions compose): the `l = 0`,
`⟨a,b⟩ = −2` case (`NegTwoFirstDerivZero`, `NegTwoExactResidualAligned` and every equivalent name); the
`l = −2` face's `⟨a,b⟩ = 0` chamber (`WeightedZOneLineZeroPairing`), hence the **whole `l = −2` face**;
and, for every `c`, the **`ν = c−2` chamber** of the `l = −c` face (`NegCMomentLine E c 1` from
`ZLine E 1`).  **Batch 196** harvests these (A) and attempts the general-`j` induction `ZLine E j`
(`j ≥ 2`), which would close `ResidueNegativeAligned` at the even cocycle entirely (B).

**Brief errors this batch**: the "descended `z_0^0` line" premise (refuted); the index normalization in
195-A's brief (`ε·YFam (a+b) (−K−1) = ε·genFam (a+b) K`, not `(K+1)`); and "the unweighted diagonal sum at
a descendant" is not a statement until the window is fixed (with the generator's own window it is false).
---

### Batch 196 — the general-`j` induction `ZLine E j` is LANDED conditional on the single `c`-independent base `ZLineGeneratorBase`; the `l = −2` face and every `ν = c−2` chamber become UNCONDITIONAL

**A — the harvest** (`Definitions/MMFLM86HarvestAllPairings.lean`, `Definitions/MMFLM86HarvestAllPairingsFaces.lean`).
With `ZOneLineAllPairings` a theorem (batch 195), the landed one-directional reductions compose with no
hypothesis left.  `negTwoFaceAligned_evenCocycle` closes the **whole `l = −2` face** at FLM's datum, and
`negCFaceAlignedFrom_subTwo_evenCocycle` closes the `ν ≥ c−2` chamber of **every** `l = −c` face.  The
sharpest new form is the equivalence
```
residueNegativeAligned_evenCocycle_iff_negThreeAndBelow :
  ResidueNegativeAligned (evenCocycle …) ↔ NegThreeAndBelowResidualAligned
```
i.e. the whole negative-pairing residue at the even cocycle is *exactly* the `⟨a,b⟩ ≤ −3` chamber: the
`l = 0` cases `⟨a,b⟩ ∈ {0,−1,−2}` are paid for, and no `l ≠ 0` face is left behind for those pairings.
This is a strict advance in accounting — the earlier "`⟨a,b⟩ ≤ −1`" residual is replaced by
"`⟨a,b⟩ ≤ −3`" plus a theorem.  Also harvested: every equivalent `z_0^1` residual name.

**B — the induction** (`Definitions/MMFLM86ZLineInduction.lean`, 873 lines).  The level induction on
`ZLine E j` is LANDED, conditional only on the named base:
```
theorem zLine_all_of_generatorBase (hs) (E) (h : ZLineGeneratorBase (F := F) bL form E) :
    ∀ i : ℕ, 1 ≤ i → ZLine (F := F) bL form E i
theorem zLineGeneratorBase_iff (hs) (E) :
    ZLineGeneratorBase (F := F) bL form E ↔ ∀ i : ℕ, 1 ≤ i → ZLine (F := F) bL form E i
theorem negCBinomMomentAligned_of_generatorBase (hs) (E) (h) {c} (hc : 1 ≤ c) :
    NegCBinomMomentAligned (F := F) bL form E c
```
Ingredients proved: the `j`-independent contraction `momentSum_modeVL_normOrdered2` at weight `C(r,j)`;
the Chu–Vandermonde identity `binomCoeff_sub_eq_sum_moment` (`C(p−r,j) = Σ_l C(−r,l)C(p,j−l)`);
F-linearity of the line values in the state `zLineAtVal_of_mem_span`; the step
`zLineAt_modeVL_of_modeLaw`; the level induction `ZLineAtAllLevel`/`_succ`/`_all`; and the spanning
assembly `zLineScheme_of_level`/`zLine_of_level`.  `zLine_one_unconditional : ZLine E 1` re-derives
batch 195-B without the base.  So **the whole `ZLine` tower for `j ≥ 2` is one base away**, and that base
is `c`-independent.

The base has exactly TWO halves:
```
def ZLineGeneratorBase (E) : Prop :=
  (∀ a b c₀ i K, ZLineAt (normOrdered2 a b) i K (iotaVL c₀) (zLineVal E a b i K (iotaVL c₀)))
  ∧ (∀ a b c i r, 1 ≤ r → ∀ K u, ZLineModeAt (F := F) bL form E a b c i r K u)
```
(i) the order-`i` line at the lattice generators, and (ii) the order-`i` **mode law** for the field of the
coherent state `E⁻_a(z)_i ι(ab)` through one creation mode `YFam`.  Both halves are landed for `i ≤ 1`
(`zLine_zero`, `zOneLineAllPairingsOnGenerators`; `modeVL_genFam_sub`, `ZAligned_modeVL`); `i ≥ 2` is new.
The converse direction of `zLineGeneratorBase_iff` is proved by linearising the contraction over the line
windows.

**`ResidueNegativeAligned` at the even cocycle is still NOT unconditional**: it needs `ZLine E j`,
`j ≥ 2`, hence `ZLineGeneratorBase`.

**Brief errors this batch** (three corrections, all consequential).
(a) `zLineAt_firstDeriv` is an **equivalence**, so it cannot manufacture the generator case from landed
material; order 0 of `firstDeriv^j(normOrdered2 a b)` is the same difficulty, because
`firstDeriv^j(normOrdered2)` is not a `normOrdered2` and `assemblyDiagonal_antidiagonal` is stated only for
`normOrdered2 a b`.
(b) The step needs the **lower-order** lines at degree `K+r`, not only order `j` at all monomials.
(c) The step also consumes the **value law at the descendant** (`ZLineModeAt`); `ZAligned_modeVL` covers
only `j = 1`.  Hence the base has two halves, not one generator case.
(d) Arithmetic trap (carried from 195): `zLineVal 0 K u = ε·genFam (a+b) K u`, since
`genFam u m = YFam u (−m−1)`; the first draft had the index off by one and the mode law would have been
false.

---

### Batch 197 — the order-2 line is reduced to exactly TWO statements (`zLine_two_iff`), and the Fock half is reduced to the `k = 2` display plus two named carrier inputs

**A — the truncated base and the exact order-2 residual** (`Definitions/MMFLM86ZLineBaseUpTo.lean`, 401
lines, `MM.FLM86ZLT`; `Definitions/MMFLM86ZLineTwo.lean`, 366 lines, `MM.FLM86ZLT2`).  Batch 196's
single `c`-independent base is now **truncated** without loss:

```
theorem zLineGeneratorBaseUpTo_iff (hs) (E) (J) :
    ZLineGeneratorBaseUpTo E J ↔ ∀ i : ℕ, i ≤ J → ZLine E i
theorem zLineGeneratorBase_iff_forall_upTo (hs) (E) :
    ZLineGeneratorBase E ↔ ∀ J, ZLineGeneratorBaseUpTo E J
```

both directions at the *same* `J` — neither uses an order above `J`, so the brief's feared failure of
one direction does not occur.  The chamber consumption is now per-chamber and sharp:

```
theorem negCBinomMomentAlignedAt_of_lines (hs) (E) {c nu J} (hc : 1 ≤ c)
    (hJ : ∀ j, 1 ≤ j → j ≤ J → ZLine E j) (hnu : nu ≤ c - 2) (hcJ : c - 1 - nu ≤ J) :
    NegCBinomMomentAlignedAt E c nu
theorem negCBinomMomentAlignedAt_of_zLine_two (hs) (E) ... :
    NegCBinomMomentAlignedAt E c nu      -- every chamber with c - 1 - nu ≤ 2, new chamber nu = c-3
```

and the order-two residual is **exactly two statements**:

```
theorem zLine_two_iff (hs) (E) : ZLine E 2 ↔ (order-2 line at the lattice generators) ∧ (order-2 mode law)
```

(the `i = 0, 1` halves being the landed `zLine_zero`, `zLine_one_unconditional`, `zLineModeAt_zero`,
`zLineModeAt_one`).  The file also lands the whole (8.4.16)/(8.4.12) **window-shift engine for the
derived factor** `a'(z) = (1/1!)(d/dz)a(z)`: the closed forms of its halves
(`splitMinus_factorFamilyZero_two`, `splitPlus_factorFamilyZero_two`), the head/tail discrepancies and
their two-component shifted forms (`headWindow_factorFamilyZero_two_modeVL_sub`/`_shift`,
`tailWindow_factorFamilyZero_two_modeVL_sub`/`_shift`), and the commutator
`[α_c(-r), splitPlus a'(z)]` giving the tail correction `-r(r+1)⟨c,a⟩ Y_{m+r+2}` at window `M ≥ r+1`.

**A did NOT land** `zLineModeAt_two`, the order-2 generator line, or `zLine_two`.  The order-2 mode
law's remaining step is pinned down in three parts in the file header: (1) the (8.5.5) recursion at
degree two, `ZAligned E (E⁻_a(z)₂ w) = (eps/2)·reflectFam(C' + D)` with
`C' = actionFamily (factorFactorZero 1 a) W`, `W = YzeroField baseAligned (E⁻_a(z)₁ iota(a+b))`,
`D = actionFamily (factorFactorZero 2 a) (baseAligned E (a+b))`; (2) the **two applied laws** — the
two-component `heisFamZero a` law for `W` (whose commutator is `ZAligned_modeVL` rearranged,
inhomogeneous, correction `r⟨a,c⟩` from the (8.4.19) `⁺`-tail) and the homogeneous law for `D`; (3) the
identifications `zLineVal 1 (K+r) u = eps B_{K+r-1} u`, `zLineVal 0 (K+r) u = eps genFam(a+b)_{K+r} u`,
`C(-r,2) = r(r+1)/2` and the coefficient identity `-⟨c,a⟩ r(r+1)/2 = -(the C(-r,2) term)`, whose
arithmetic closes exactly against the `ZLineModeAt` right-hand side.

**B — the Fock half at its shortest** (`Definitions/MMFLM86FockOneStep.lean` 333 lines,
`...Sharp.lean` 197, `...Two.lean` 281).  At a general `E` (no cocycle, no evenness), with two newly
named carrier inputs

```
def FockPairDatum E  := OneSidedCreatedPairs (ZAligned E) vacuumVL
def FockCreatedSpan E := Submodule.span F (Set.range (iteratedCreation (ZAligned E) vacuumVL)) = ⊤
```

both directions are landed:

```
theorem fockCreatedStep_iff_createdStep (E) (hpair) (hspan) :
    FockCreatedStep E ↔ IterateProductStepOnCreated (ZAligned E) convOneSided vacuumVL
theorem fockCreatedStep_iff_display8610List (E) (hpair) (hspan) :
    FockCreatedStep E ↔ Display8610List (ZAligned E) vacuumVL convOneSided
theorem fockCreatedStep_iff_display8610TwoOneSided (hnd) (hs) (E) (hpair) (hspan) :
    FockCreatedStep E ↔ Display8610TwoOneSided E
theorem coherentCreatedStep_of_twoOneSided (hnd) (hs) (E) (hpair) (hspan) :
    Display8610TwoOneSided E → CoherentCreatedStep E
```

so the `k = 2` display is **sufficient**, not merely necessary, and `CoherentCreatedStep` is now
consumable from a concrete display instead of the opaque one-step.  New mathematics: the conditional
additivity of the `dite`-carrier `convOneSided` (`convOneSided_add_right_of_pairFinite`,
`_smul_right_of_pairFinite`), `PairFinite` preserved along the span
(`pairFinite_shiftedField_of_mem_span`), and the **sharpness refutation**
`not_convOneSided_add_right_unconditional` (a compiled counterexample over `ℚ`: unconditional
additivity of `convOneSided` is FALSE, so the carrier input cannot be dropped).  Non-vacuity of the
datum is recorded (`fockPairDatum_created_nil`, `fockPairDatum_created_singleton_iotaVL`).

**Accounting corrections of record.**  (1) The Fock residual is **two-layered**: the created-state
evaluation (the `k = 2` display `Display8610TwoOneSided`, i.e. the (8.5.5) evaluation of (8.5.14))
**plus** the carrier datum `FockPairDatum` (which is strictly stronger than batch 182's
`ShiftedPairFiniteGenerators`: all created states and all factors, not the lattice generators only) and
the spanning `FockCreatedSpan`.  The ledger line "the Fock half is implied by the landed (8.6.10) gap
`IterateProductStep`" should be read as "equivalent to the `k = 2` display modulo those two named
carrier inputs".  (2) The brief's chamber lemma `negCBinomMomentAlignedAt_of_lines` is **false at
`c = 0`** (at `(c,ν) = (0,0)` the order is `k = 0` and the landed (8.4.20) assembly computes the left
side as `ε·YFam(a+b)(m+n+1)` against the stated `ε·YFam(a+b)(m+n)`); the landed form carries
`hc : 1 ≤ c`, which every face consumer has.  (3) The brief understated the order-2 mode law: its first
summand acts on the degree-one field, whose commutator with `α_c(-r)` is **not** homogeneous (the
(8.4.19) `⁺`-tail), so the landed homogeneous `actionFamily_modeVL` does not apply as it stands.

**Lead for the next batch (dispatcher).**  `MM.FLM85CA.createdStateSpan_eq_top`
(`MMFLM85ConvAdditive.lean:502`) **is** a landed proof that the created states span `V_L`, from
`hcreate : CreationProperty (toVertexOp Y) vac` and `hmode : ∀ p : ℕ+ × L, (Y (umode p)) (-p.1) = modeVL p.2 (-p.1)`
plus an explicit family `umode`.  So `FockCreatedSpan E` is very likely dischargeable at `ZAligned E`
(the landed (8.5.23) `creationPropertyAligned` supplies `hcreate`) rather than being a genuine new
residual; the (8.5.2) mode identification is the only hypothesis to locate.

---

### Batch 198 — 🎉 `ZLine E 2` IS A THEOREM: both halves of the order-two base landed (MODE2 + GEN2), and the `ν ≥ c−3` chamber of every `l = −c` face is now unconditional

**A — MODE2** (`Definitions/MMFLM86ModeLawTwo.lean`, 618 lines, `MM.FLM86MLT`): `zLineModeAt_two` at a
general `E` with only `hs`, i.e. the order-two mode law `ZLineModeAt E a b c 2 r K u` for all data and all
`1 ≤ r`.  The proof needed two things batch 197-A had not landed: the **two-component window laws for the
factor `a(z)` itself** (`headWindow_heisFamZero_two_modeVL_shift`, `tailWindow_heisFamZero_two_modeVL_shift`,
correction `r⟨a,c⟩Y_{m+r+1}`, bound `r ≤ M`) built from the landed `MM.FLM810CC.modeVL_headWindow_sub` /
`modeVL_tailWindow_sub`, and the generic applied law `actionFamily_two_modeVL_of` together with its two
instantiations: `actionFamily_factorFactorZero_one_two_modeVL` (the factor `a(z)` against the degree-one
coherent field, correction `+2r⟨a,c⟩B_{m+r+1}` — the (8.4.19) tail and the two-component `δ`-term ADD,
no cancellation) and `actionFamily_factorFactorZero_two_two_modeVL` (the derived factor, correction
`-r(r+1)⟨c,a⟩Y_{m+r+2}`, window `r+1 ≤ M`).  With `zAligned_creationExpVL_two_anchor` (the (8.5.5)
recursion at degree two), `zLineVal_two_eq` and `binomCoeff_neg_two : C(-r,2) = 2⁻¹(r+1)r`, the final
assembly closes exactly against the `ZLineModeAt` right-hand side.  Packaging: `ZLineTwoGenerator`,
`zLine_two_of_generator` (the order-two line now needs GEN2 ALONE) and
`negCBinomMomentAlignedAt_of_generatorTwo`.

**B — GEN2** (four files, 336 + 365 + 241 + 272 = 1214 lines, `MM.FLM86GLT`:
`MMFLM86GeneratorLineTwoAux/Eval/Comp/GeneratorLineTwo.lean`): `zLineGeneratorTwo` — the order-two line
`ZLineAt (normOrdered2 E a b) 2 K (iotaVL c) (zLineVal E a b 2 K (iotaVL c))` for all `a b c`, `K`, at a
general `E` with only `hs`.  Engine: the quadratic weight `2·C(T,2) = T(T-1)` and the second-order weight
bridge to `flatMul (deriv (deriv X))`; the window→`flatMul` bridges for the corrected (8.4.16) head against
a SHIFTED field (`headWindow_eq_flatMul_of_shift`/`_of_shift`, relating the source vector `w` and the
target vector `w'` separately); `splitMinus (factorFamilyZero 2) = deriv` of the creation half; the two
(8.5.5) evaluations at `iota(c)` (`momentSum_two_iotaVL`, `zLineVal_two_iotaVL`) and the composite
`:a(z)a(z)Y(ab,z):` action (the head needs the SQUARE of the creation half via `flatMul_assoc`).  The two
sides meet by `2·C(T,2) = T(T-1)`.  Also `zLine_two_iff_modeLaw : ZLine E 2 ↔ MODE2` (the GEN2 half is
discharged).

**Capstone (dispatcher), `Definitions/MMFLM86ZLineTwoClosed.lean`**: `zLine_two : ZLine E 2`
(unconditional), `zLineGeneratorBaseUpTo_two : ZLineGeneratorBaseUpTo E 2`,
`negCBinomMomentAlignedAt_of_two` — the chamber `c-1-ν ≤ 2` (the new chamber `ν = c-3` included) of every
`l = -c` face, at the single symmetric-pairing hypothesis.  No new mathematics: compositions of the two
halves.

**Campaign-level trap discovered by the capstone (record it).**  A declaration whose STATEMENT fails to
elaborate (here an unknown identifier: the dispatcher's file used `CentralExtension` without
`open FLMLattice`) is silently turned into a `sorryAx` term; `#print axioms` then reports
`[propext, sorryAx, Classical.choice, Quot.sound]` and the ONLY symptom is the `#guard_msgs` mismatch.
Two consequences: (a) always scan the whole build log for `error` lines, not just the final
`--- OK/FAILED`; (b) never trust `tools/build.sh … | tail` for the exit code (the pipeline reports
`tail`'s status — this masked a `DRIVER_EXIT=1` for one round).  A scratch probe that `#print axioms`
every public declaration without a guard docstring is the reliable check.

**Brief errors this batch.**  (a) "importing `MMFLM86ZLineTwo` gives `zLine_two_iff`" is false — that
lives in `MMFLM86ZLineBaseUpTo` (`MM.FLM86ZLT`); both imports are needed.  (b) The "landed engine" covered
only the DERIVED factor `(1/1!)(d/dz)a(z)`; the `a(z)` half (two window laws + generic applied law) was
the largest unrecorded piece of work.  (c) `M ≥ r+1` is needed for the derived factor only; the generic law
carries `r+1 ≤ M`.  (d) The final assembly needs three ring index identities applied in a specific order
(`(K+r)-2 = K-2+r`, `-(-(K+r))-1 = K-2+r+1`, `K+r = K-2+r+2`); a `simp` normalisation applies them in the
wrong order and leaves `K-2+r+2-2`.  (e) Two measured Lean traps: `rw`/`simp [neg_smul]` does not fire on
`(-A) • x` for `x : VL F L` (module instance diamond — use `module` or `(neg_smul A x).symm`), and
`rw [← smul_add]` can rewrite the OUTER `(1/2) • (…)` (use `(smul_add _ _ _).symm` in a `calc`).
(f) 198-B's derivative-ladder LEAD does not work: the order-one generator line is landed for
`normOrdered2` itself, not for its derivative; the direct route closed instead.

---

### Batch 199 — both halves of the general-`j` base are reduced to ONE named residual each; the left-hand side of the generator line is unconditional at EVERY `j`

**A — MODE-ALL** (`Definitions/MMFLM86ModeLawAllAux.lean`, 633 lines + `Definitions/MMFLM86ModeLawAll.lean`,
507 lines, namespace `MM.FLM86MLA`).  The order-`j` mode law for all `j` is now equivalent to one named
induction step `AnchorModeCommStep E`, with all the analytic machinery landed at a general `E` with only
`hs`:

* **the general-`n` (8.4.16)/(8.4.19) window law for the derived factor `(1/(n-1)!)(d/dz)^{n-1}a(z)`, for
  every `n >= 1`**: `splitMinus_factorFamilyZero_eq` (`splitMinus (factorFamilyZero n a) i =
  C(i+n-1,n-1) . alpha_a(-i-n)`), `splitPlus_factorFamilyZero_eq`, `splitPlus_factorFamilyZero_modeVL_sub`
  (the commutator fires exactly at `k = r+n-1` with coefficient `n.<c,a>C(-r,n)`), the head/tail window
  discrepancies and their shifted forms (tail repair `-n.<c,a>C(-r,n).Y_{m+r+n}`, window `r+n-1 <= M`),
  `actionFamily_modeVL_of_window` (the applied law with an EXPLICIT window bound) and
  `actionFamily_factorFactorZero_modeVL` (every `n >= 1`, instantiating the landed `n = 1, 2` cases);
* the (8.5.11) anchor field `A_m = YzeroField (baseAligned E) (E^-_a(z_0)_m iota(ab))` with
  `zLineVal_eq_anchorField : zLineVal j K u = A_j.fam (K-j) u`, the (8.5.5) recursion
  `anchorField_recursion`/`_apply` (`A_j.fam = (1/j) sum_{i<j} actionFamily (factorFactorZero (i+1) a) A_{j-1-i}`);
* the commutator form `AnchorModeComm` with the IFF `zLineModeAt_iff_anchorModeComm`, the base cases
  `anchorModeComm_zero`/`_one`, the triangle transpose `sum_range_triangle`, and the applied law with a
  finite family of correction fields `actionFamily_modeVL_of_sumWindow`;
* **`def AnchorModeCommStep E`** (the ONE named residual) with `anchorModeComm_all_of_step` and
  `zLineModeAt_all_of_step : AnchorModeCommStep E -> forall j a b c r, 1 <= r -> forall K u, ZLineModeAt ...`,
  and `anchorModeCommStep_of_le_two`: **the residual is a theorem for every `j <= 2`**, so every remaining
  failure sits at `j >= 3`.

Only the index bookkeeping of the step is unwritten, and the report verifies the coefficient count closes
exactly: `(1/j)(j-1-l)<c,a>C(-r,l+1) + (1/j)(l+1)<c,a>C(-r,l+1) = <c,a>C(-r,l+1)`.  The coefficient identity
used is `n.C(-r,n) = (-1)^n r.C(r+n-1,n-1)` (`nat_mul_binomCoeff_neg`), from
`MM.FLM86R.binomCoeff_neg_cast` + `MM.FLM84SM.binomCoeff_succ_mul`.

**B — GEN-ALL** (`Definitions/MMFLM86GeneratorLineAllAux.lean`, 281 lines + `...All.lean`, 306 lines,
namespace `MM.FLM86GLA`).  The order-`j` line at the lattice generators is NOT closed for `j >= 3`, but:

* the **left-hand side is evaluated unconditionally at every `j`**: `sum_Icc_binomCoeff_eq_flatMul_iterDeriv`
  (the order-`j` weight bridge `sum_{i in Icc 0 N} C(i,j) X_i (Y_{N-i} w) = (j!)^{-1} flatMul (iterDeriv j X) Y (N-j) w`),
  `normOrdered2_iotaVL_eq_zero_of_not_mem_window`, and `momentSum_iotaVL_flat` (the order-`j` moment at a
  generator over the flat window equals `flatGeneratorValue`);
* the target is **exactly equivalent** to one named residual: `zLineAt_iotaVL_iff_flat` (pointwise, no
  hypothesis) and `zLineGeneratorAll_iff_flat : ZLineGeneratorAll E <-> ZLineGeneratorFlat E`, plus
  `zLineGeneratorFlat_iff_zAlignedGeneratorFlat`;
* **`def ZAlignedGeneratorFlat E`** (the named residual) is exactly "the (8.5.5) recursion
  `coherentFieldNat_eq` evaluated at a lattice generator", open for `j >= 3`;
* `zLineAtGenerator_upTo_two` / `zLineAtGeneratorFlat_of_le_two`: the `j <= 2` slice, a machine-checked
  consistency test of the index conventions against batch 198's GEN2.

The report's hand computation says the missing induction closes and names its ingredients:
(i) `splitMinus (factorFamilyZero (r+1) a) = (r!)^{-1} iterDeriv r (splitMinus (heisFam a))`;
(ii) the `^+`-tail at `iota(c)` (`k != r` killed by `modeVL_iotaVL_eq_zero_of_pos`, the `k = r` term
`(-1)^r <a,c>`); (iii) the head collapse via `sum_range_eq_flatMul` + `flatMul_assoc` plus two unnamed
bookkeeping lemmas (head-window additivity, a KillsAbove bound for flat families); (iv) the `j`-fold Leibniz
recursion `D_j = sum_r C(j-1,r) flatMul (iterDeriv r a^-) D_{j-1-r}`; (v) `s.C(s-1,q-1) = q.C(s,q)`.

**Brief errors this batch.**
(a) The general-`i` window law needs NO Leibniz induction: the closed forms above give it in one step each
from `MM.FLM810ZM.splitMinus_factorFamilyZero_eq` + `FLM85Ac.iterDeriv_apply_smul`.
(b) **A real gap in the landed template**: `MM.FLM86MLT.actionFamily_two_modeVL_of` hardwires the tail window
bound `r+1 <= M`, which does not give `r+n-1 <= M` for `n >= 3`; `actionFamily_modeVL_of_window` fixes it.
(c) The order-`j` weight expansion is `MM.FLM86ZM.binomCoeff_add_eq_sum`, NOT
`MM.FLM86ZLI.binomCoeff_sub_eq_sum_moment` (that one is the moment-level, mode-law expansion).
(d) `MMFLM86LS.lean` does not exist: `normOrdered2_iotaVL` is in `MMFLM86LimitStep.lean:482`.
(e) "GEN2 generalises almost verbatim" holds only for the LEFT half: the order-2 right-hand composite acts on
the honest base field, while for `j >= 3` the factor acts on the field of a lower coherent state (a flat
sum), and there is no landed general-`r` analogue of `actionFamily_one/two_base_iotaVL`.
(f) The final identification in the mode law is not a direct coefficient match: it needs the (8.5.5) recursion
at order `j-1-l` and the triangle transpose, and the tail coefficient `-n<c,a>C(-r,n)` is exactly what makes
the count close.

---

### Batch 200 — the Fock carrier input is discharged; the GEN-ALL computation is complete up to one finite-sum assembly

**A — GEN-ALL induction** (`Definitions/MMFLM86GeneratorLineAllIndAux.lean`, 575 lines, 20 guards +
`Definitions/MMFLM86GeneratorLineAllInd.lean`, 249 lines, namespace `MM.FLM86GAI`).  Every input of the
residual `MM.FLM86GLA.ZAlignedGeneratorFlat` is now landed, at a general `E` with only `hs`:

* the algebra: `algebraMap_rat_inv_natCast`, `binomCoeff_mul_pred` (`s.C(s-1,q-1) = q.C(s,q)`),
  `sum_range_alternating_binomCoeff` (`sum_{r<=n} (-1)^r C(s,n-r) = C(s-1,n)`), the triangle reindexings
  `sum_range_triangle_swap`/`_shift`/`_shift_plus`, `prod_range_sub_eq_neg_pow_mul_factorial`;
* item (i): `splitMinus_factorFamilyZero_succ` (the creation half of the next derived factor), through
  `heisFamZero`;
* item (ii): `splitPlus_factorFamilyZero_succ_apply_iotaVL`, `killsAbove_factorFamilyZero_succ_iotaVL`,
  `tailWindow_factorFamilyZero_succ_iotaVL` — **the window replacement cannot use `r+1 <= factor.bound`**
  (the `k = r` value `(-1)^r <a,c>` may vanish); compare `max bound (r+1)` instead;
* item (iv) **CORRECTED**: the record's `D_j = sum_r C(j-1,r) flatMul (iterDeriv r a^-) D_{j-1-r}` is FALSE
  (at `j = 2` it gives `2 flatMul a^- E^-_{a+b}`, against the true
  `flatMul (deriv a^-) E^-_{a+b} + flatMul (a^- a^-) E^-_{a+b}`); the landed correct identity is
  `sum_{r+p=N-1} (r! p!)^{-1} flatMul (iterDeriv r U) (flatMul (iterDeriv p E) Z) = ((N-1)!)^{-1} flatMul (iterDeriv N E) Z`
  (`sum_factorial_flatMul_iterDeriv`, with `iterDeriv_flatMul`, `deriv_sum`, `iterDeriv_deriv_general`,
  `factorial_inv_mul_choose`);
* the (8.4.16) head against the flat value at ALL orders and any `E` (`sum_head_flatGeneratorValueZ`,
  `flatGeneratorValueZ_eq_zero_of_lt`), the tail collapse (`tailOp_factorFamilyZero_flatGeneratorValueZ`,
  using the induction hypothesis as a hypothesis), and the (8.5.5) recursion at a lattice generator in
  component form (`ZAligned_creationExpVL_eq_sum_actionFamily`).

**The remaining step is one finite-sum identity (ASSEMBLY)**, with every input landed:
`(sum_{r<j} head_r) + (sum_{r<j} tail_r) = j . eps(a+b,c) . sum_{l<=j} C(s,l)((j-l)!)^{-1} D_{j-l}(N_l) iota(a+b+c)`,
proved by `sum_range_triangle_swap` + `sum_factorial_flatMul_iterDeriv` (head) and
`sum_range_triangle_shift_plus` + `sum_range_alternating_binomCoeff` (tail), with the coefficients closing
at every offset `l <= j` via `binomCoeff_mul_pred` and `j.(j!)^{-1} = ((j-1)!)^{-1}`.  The report hand-verifies
that the induction closes.

**B — the Fock carrier** (`Definitions/MMFLM86FockCarrier.lean` 237 lines, `...Aux.lean` 394,
`...Span.lean` 162, namespace `MM.FLM86FC`/`MM.FLM86FCA`).  **`FockCreatedSpan E` IS DISCHARGED
UNCONDITIONALLY** (`fockCreatedSpan`, no `hs`): the landed `MM.FLM85CA.createdStateSpan_eq_top`'s two inputs
are the landed (8.5.23) `creationPropertyAligned` (its `vertexOpOfField (Yaligned E)` spelling is
DEFINITIONALLY the required `toVertexOp (ZAligned E)` — no bridge lemma needed) and the (8.5.2) identification
at `umode p = modeVL p.2 (-1) vacuumVL`, which is now PROVED (`zAligned_modeVL_neg_one_vacuum`), so no
`ModeIdentification` residual had to be named.  Hence the Fock residual takes ONE carrier input:
`coherentCreatedStep_of_twoOneSided_of_pairDatum`, and the three `fockCreatedStep_iff_*` forms take only
`FockPairDatum E`.

The carrier datum is then reduced: `fockPairDatum_iff_pairFiniteAll` (`FockPairDatum E <-> PairFiniteAll E`,
i.e. `forall a x, PairFinite (ZAligned E a) (ZAligned E x)`, via the shift-invisibility
`pairFinite_shiftedField_iff` and the now-proved spanning) — so **"lists of length >= 2" is not an
independent case**; the new closure laws `pairFinite_add_left`/`_smul_left` (not landed before) and
`pairFinite_linearMap_of_mem_span`; the positive part extended along spans under pairwise `0 <= <c,d>`
(`pairFinite_shiftedField_span_left`, `pairFinite_span_span`, `pairFinite_created_singleton_span_left`);
the named residual `PairFiniteNegPairing E` (negative pairing at lattice generators) and
`pairFiniteGeneratorsAll_of_negPairing`; and `fockPairDatum_imp_negPairing`, which shows the batch-197-B
carrier input is strictly stronger than batch 182's `ShiftedPairFiniteGenerators`.  The report's numerical
note (not formalized, nothing depends on it): the naive "negative pairing forces an infinite OPE tail" worry
is WRONG — the summand is a diagonal extraction and cancels.

**Correction of record**: batch 199-B's §3 item (iv) is FALSE as recorded and is corrected by the landed
`sum_factorial_flatMul_iterDeriv` above.  `NOTES §95.5`'s "GEN-ALL open" remains correct.

**Brief errors (B200-A).**  (1) item (iv) was false (see above).  (2) item (iii)'s head-window additivity and
flat-family KillsAbove are NOT needed.  (3) item (ii)'s window replacement needs `max bound (r+1)`, not the
factor's own bound.  (4) No `c`-independent operator-valued flat family can equal `ZAligned` at the coherent
state (the (8.4.17) shift lives in the value at `iota(c)`); the head must be stated against the flat value at
components `n+i`.  (5) item (i) goes through `heisFamZero`.
**Brief errors (B200-B).**  (1) No `vertexOpOfField`/`toVertexOp` bridge is needed (definitional).
(2) No `hs` is needed for the span.  (3) `pairFinite_add_left`/`_smul_left` were missing from the tree.
(4) The "arbitrary single-factor `a` via `spanningStatement`" route is incomplete (`{iota(c)}` does not span
`V_L`).  (5) The "lists of length >= 2" item conflates the carrier datum with the created-state step.

---

### Batch 201 — 🎉 the MODE-LAW half is UNCONDITIONAL (`zLineModeAt_all`), and the `l = 0`, `<a,b> <= -3` residual is reduced to a `normOrdered2`-only statement

**A — MODE-ALL CLOSED** (`Definitions/MMFLM86ModeLawAllStepAux.lean`, 290 lines +
`Definitions/MMFLM86ModeLawAllStep.lean`, 571 lines, namespace `MM.FLM86MLA`).  The batch-199-A residual
`AnchorModeCommStep E` is a THEOREM at a general `E` with only `hs`, hence

```
anchorModeCommStep (hs) (E) : AnchorModeCommStep E
anchorModeComm_all (hs) (E) : forall j a b c r, 1 <= r -> AnchorModeComm j r
zLineModeAt_all (hs) (E) : forall j a b c r, 1 <= r -> forall K u, ZLineModeAt (F := F) bL form E a b c j r K u
```

**so the second half of `ZLineGeneratorBase` is unconditional and the base now rests on the generator half
`ZAlignedGeneratorFlat` ALONE** (this supersedes the "mode law ⟺ `AnchorModeCommStep`" row of NOTES 97.4).
The missing input was the (8.4.16)/(8.4.19) head/tail shift against a FINITE FAMILY of correction fields
(`headWindow_factorFamilyZero_modeVL_shift_sum`, `tailWindow_factorFamilyZero_modeVL_shift_sum`): the landed
`actionFamily_modeVL_of_sumWindow` keeps ONE `-gamma.headWindow` term OUTSIDE the `sum_l`, so summing the
landed single-field shifts would count it `N` times.  Then `ModeCommFam`, the abstract step
`modeCommFam_step` (consuming the (8.5.5) recursion as a hypothesis) and the anchor instantiation close the
induction.

**B — the `l = 0`, `<a,b> <= -3` residual, reduced** (`Definitions/MMFLM86NegThreeBridgeAux.lean`,
201 lines + `Definitions/MMFLM86NegThreeBridge.lean`, 740 lines, namespace `MM.FLM86NTB`):

* `negThreeExpandedResidualAligned_iff_anchorForm` (IFF, NO hypothesis) — the expanded residual IS its
  anchor-field spelling, each `coherentFieldNat E a (anchorVL E a b) (N-1-i)` replaced by
  `(anchorField E a b (N-1-i)).fam (i-m-n-1)` (new dictionary `coherentFieldNat_eq_anchorField_fam`);
* `anchorGeneratorValue_iff_zAlignedGeneratorFlat` (aux) — the anchor value at generators is **literally**
  batch 199-B's `ZAlignedGeneratorFlat`, i.e. not a new residual;
* given the named `ZLineAll E`, `negThreeAnchorForm_iff_chamberMomentForm` and
  `negThreeExpandedResidualAligned_iff_chamberMomentForm` — the residual becomes
  **`NegThreeChamberMomentForm E`**, in `normOrdered2` alone (the difference of the two (8.4.26) chamber
  series equals the single moment of weight `C(r+m,N-1)` at diagonal `N-m-n-2`, `N = (-<a,b>).toNat`);
  the weight matches the campaign's negative-pairing `ν = c-3` chamber;
* the `<a,b> = -3` slice **unconditional** (`negThreeAtMinusThree_iff_chamberMomentFormAtMinusThree`), using
  only `ZLine 0,1,2`, with the consumed `k <= 2` anchor values landed (`anchorField_generator_of_le_two`,
  `anchorValueAtMinusThree_of_le_two`);
* one-directional generator bridges landed (`negThreeAnchorForm_apply_iotaVL(_flat)`); the converse is
  explicitly NOT claimed — `{iota(c)}` spans only the lattice factor, not the Fock half.

**Corrections of record (batch 201).**
(a) The requested "residue ⟺ anchor VALUES at generators" IFF **does not exist**: the residue's left-hand side
is the honest commutator `twoVarField - swap2`, which the anchor values do not mention.  What is an IFF is the
anchor-field SPELLING (no hypothesis) and, given `ZLineAll`, the `normOrdered2` chamber/moment form.
(b) The `<a,b> = -3` slice does **not** close from the landed `k <= 2` tower: the anchor fields CANCEL there,
leaving the `N = 3` chamber collapse (`NegThreeChamberMomentFormAtMinusThree`).
(c) The residue's summand is an OPERATOR component `(anchorField ...).fam (i-m-n-1)`, not a value at
`iotaVL c` (that spelling would lose the Fock half).
(d) Lean traps: `-(C) • Z` puts the negation on the SCALAR and `a * b • c` parses as `a * (b • c)`
(`•` infixl:73 binds tighter than `*` infixl:70) while the printer renders `(-C)•Z` and `-(C•Z)`
identically — write the `delta` family as `((-1:F) * (theta * C l))`; unapplied
`rw [neg_smul]`/`[smul_sub]`/`[smul_smul]`/`[Finset.smul_sum]` fail on syntactically identical occurrences
in this pin and `abel` mangles additive indices inside atom arguments (use explicitly applied local `have`s).
(e) The `1/j` of the (8.5.5) recursion is never introduced: multiply by `j`, the coefficient
`(j-1-l) + (l+1) = j` closes, and `j` cancels by `smul_right_injective` (char 0); the reindex `t = i+1` is
unnecessary (alpha-renaming suffices).

**Accounting after batch 201**: `ZLineGeneratorBase` ⟺ `ZAlignedGeneratorFlat` (the generator half) ALONE;
`NegThreeAndBelowResidualAligned` ⟺ (given `ZLineAll`) `NegThreeChamberMomentForm`; Fock ⟺
`Display8610TwoOneSided` + `PairFiniteAll`; `EvenCocycleJacobiStep` open.

---

### Batch 202 — 🎉🎉 THE WHOLE `z_0^j` TOWER IS CLOSED: `ZAlignedGeneratorFlat` is a theorem, `ZLineGeneratorBase` is a theorem, and EVERY `l = -c` FACE IS UNCONDITIONAL at FLM's datum

**A — the ASSEMBLY, and the close** (`Definitions/MMFLM86GeneratorLineAllCloseAux.lean` 315 lines +
`...CloseTail.lean` 302 + `...Close.lean` 334, namespace `MM.FLM86GLC`, 23 public declarations each with a
guard).  At a general `E` with only `hs`:

```
zAlignedGeneratorFlat (hs) (E) : ZAlignedGeneratorFlat (F := F) bL form E
zLineGeneratorFlat / zLineGeneratorAll : ZLineGeneratorAll (F := F) bL form E
zLineGeneratorBase (hs) (E) : ZLineGeneratorBase (F := F) bL form E
zLine_all_of_generatorBase (hs) (E) : forall i, 1 <= i -> ZLine (F := F) bL form E i
negCBinomMomentAligned_of_generatorBase (hs) (E) {c} (hc : 1 <= c) : NegCBinomMomentAligned (F := F) bL form E c
```

The missing finite-sum identity is machine-checked and NAMED: `assembly` (head sum + tail sum =
`j * flatGeneratorValueZ`), with `sum_head_assembly`, `sum_tail_assembly`, `assembly_coeff`.  Batch 200-A's
hand computation is confirmed (formula right; the formalisation needed the four corrections below).  The mode-law
half was already unconditional (batch 201, `MM.FLM86MLA.zLineModeAt_all`), so `ZLineGeneratorBase` is now a
theorem and the campaign's ENTIRE `z_0^j` tower `ZLine E i` (`i >= 1`) is unconditional.

**B — the face-level consumer** (`Definitions/MMFLM810NegCFaceJ.lean`, 329 lines, `MM.FLM810NCFJ`, 9
theorems):

* `negCFaceAlignedFrom_of_lines` — the `J`-parametrised consumer: `NegCFaceAlignedFrom E c (c-1-J)` from the
  lines `1 <= j <= J` at `E = C.toCentralExtension h2`.  Batch 196's `subTwo` proof generalises VERBATIM: the
  numerical identity `c-1-(c-2) = 1` lives only inside `negCBinomMomentAlignedAt_sub_two`'s own proof, never in
  the face consumer, so **no `C(r+m,k)` weight split and no new binomial arithmetic occurs at this layer**; the
  only new arithmetic is `c-1-J <= nu -> c-1-nu <= J` (`private chamberOrder_le`);
* `negCFaceAlignedFrom_subThree_evenCocycle` — the chamber `nu >= c-3`, UNCONDITIONAL (from `ZLine E 2`);
* `negCFaceAlignedFrom_subOne_evenCocycle` — the `J = 1` chamber, re-proved by the new route (a compiled
  `example` checks it is statement-identical to the landed batch-196 theorem);
* `negCFaceAlignedFrom_iff_chambers_evenCocycle` — the SHARP equivalence
  `NegCFaceAlignedFrom E c nu0 <-> forall nu, nu0 <= nu -> nu <= c-2 -> NegCBinomMomentAlignedAt E c nu`
  (so the bound `c-1-J` loses nothing), with the converse
  `negCBinomMomentAlignedAt_of_negCFaceAlignedFrom`;
* generator-base consumers (`_of_generatorBaseUpTo`, `_of_generatorBase`, `negCFaceAligned_of_generatorBase`),
  which A's `zLineGeneratorBase` makes unconditional.

**Capstone (dispatcher), `Definitions/MMFLM810NegCFaceClosed.lean`** (4 theorems, `MM.FLM810NCFC`): the
composition --- `zLine_all`, `negCBinomMomentAligned_all` (general `E`, every `c >= 1`),
`negCBinomMomentAlignedAt_all` (the explicit chamber at the even cocycle), and

```
negCFaceAligned_evenCocycle (C) (h2) (hs) {c} (hc : 1 <= c) :
    NegCFaceAligned (F := F) bL form (C.toCentralExtension (F := F) h2) c
```

**the WHOLE `l = -c` face, every pairing `0 <= <a,b>`, at FLM's own even-lattice datum, for every `c >= 1`.**

**Four corrections of record (B202-A).**
(1) The landed Leibniz rule `MM.FLM86GAI.sum_factorial_flatMul_iterDeriv` carries ℚ-scalars
(`[Algebra QQ A]`); instantiating it at `Module.End F (VL F L)` gives `HSMul` terms that do NOT unify with the
assembly's F-scalars --- the F-scalar form is landed as `sum_factorial_flatMul_iterDeriv_F`
(`IsScalarTower.algebraMap_smul` + `map_inv0`/`map_natCast`/`map_mul`).
(2) The head window replacement is OFF BY ONE: the kills-bound must be `M0+1` with
`M0 = (q - <a,b+c> - n - 1).toNat` (the flat value at `i = M0` need not vanish);
`sum_head_flatGeneratorValueZ` is applied with `M = M0+1`.
(3) The head is applied to a component and then to `iotaVL c` while the Leibniz lemma is family-level: an
explicit `Finset.sum_apply`/`LinearMap.sum_apply`/`Pi.smul_apply`/`LinearMap.smul_apply` distribution step is
required (this is what hides (1) in the report's notation).
(4) The tail reindexing cannot be a direct `rw` (the Nat subtraction `(r+1+l)-1-r` does not reduce
definitionally): an explicit `Finset.sum_congr` conversion is needed, the `L = 0` term must be split off before
`sum_range_alternating_binomCoeff`, and a final scalar reorder `eps*s*Fc*C = eps*s*(C*Fc)`.
**Six corrections of record (B202-B)**: (i) the template leaves `E` unbound (bind `E = C.toCentralExtension h2`);
(ii) "check where `subTwo` uses `c-1-(c-2)=1`" is a false premise (it is in the chamber theorem, not the
consumer); (iii) no `C(r+m,k)` weight split at the consumer; (iv) the chamber arithmetic
`c-1-J <= nu -> c-1-nu <= J` was not landed; (v) `negCFaceAlignedGe_evenCocycle` is the whole range
`nu >= c-1`, not a single chamber; (vi) "reproduces batch 196" can only be a statement-level check.

**Accounting after batch 202**: the `l != 0` content of (8.8.41) --- every `l = -c` face, every chamber, every
`c >= 1` --- is UNCONDITIONAL at FLM's datum.  The remaining inputs of Theorem 8.10.2 are the `l = 0` face at
`<a,b> <= -3` (`NegThreeChamberMomentForm`), the Fock half (`Display8610TwoOneSided` + `PairFiniteAll`), and
the assembly `EvenCocycleJacobiStep` (the `l = 0` assembly at (8.6.2) states + the passage from `Res_{z_0}` to
(8.10.8)).

---

### Batch 203 — the Fock ledger is corrected (the carrier inputs are NOT inputs of Theorem 8.10.2), the `l = 0` face is assembled at ALL states up to one one-mode step, and the `<a,b> <= -3` residual's exact status is settled

**A — the `<= -3` residual is not weaker than its chamber spelling** (`Definitions/MMFLM86NegThreeChamberAux.lean`
380 lines + `Definitions/MMFLM86NegThreeChamber.lean` 356 lines, 30 guards).  With the `ZLineAll` hypothesis now
DISCHARGED (`zLineAll_of_symmetricForm`, batch 202), both directions hold at a general `E` with only `hs`:

```
negThreeAndBelowResidualAligned_iff_chamberMomentForm (hs) (E) :
    NegThreeAndBelowResidualAligned E <-> NegThreeChamberMomentForm E
negThreeExpandedResidualAligned_iff_chamberMomentForm' (hs) (E) : (same, expanded spelling)
```

so **`NegThreeChamberMomentForm E` IS the open `l = 0`, `<a,b> <= -3` residual**, in `normOrdered2`-alone
spelling.  No pointwise slice is cheaper: `residueAtN_iff_chamberMomentAtN` for every `N >= 1`, and
`NegThreeChamberMomentForm E <-> ChamberMomentAtN E 3 /\ (forall N >= 4, ChamberMomentAtN E N)` with the `N = 3`
slice being batch 201-B's theorem.  New landed shapes: the whole-negative-pairing chamber form
`AllChamberMoment`, `ResidueNegativeAligned <-> AllChamberMoment`,
`allChamberMoment_iff_slices : AllChamberMoment E <-> ChamberMomentAtN E 1 /\ ChamberMomentAtN E 2 /\
NegThreeChamberMomentForm E`, the `N = 1, 2` slices as theorems at FLM's even-cocycle datum, and
`residueNegativeAligned_iff_negThreeChamberMomentForm_evenCocycle` (the chamber-spelling mirror of batch 196).
**New refutation**: `not_allChamberMoment_rankOne` --- at the rank-one datum (`Q`, `<m,n> = mn`, `extR`) the
`N = 1` slice FAILS, so evenness is *proved* necessary there; no obstruction exists at `N >= 3`.
**Recommendation of record: do NOT dispatch further "prove `NegThreeChamberMomentForm`" tasks** --- they are
identical to proving the `<= -3` residual itself.

**B — the Fock ledger correction, and the all-states assembly** (`Definitions/MMFLM86FockDisplaySharp.lean`
295 lines + `Definitions/MMFLM86Corollary851AllStates.lean` 321 lines).

```
display8610TwoOneSided_iff_fockCreatedStep (E) : Display8610TwoOneSided E <-> FockCreatedStep E   -- NO hypotheses
```

**Mechanism**: the display's `l = 0` slice spends the UNCONDITIONAL (8.5.23) creation property at `(v,0)`, so it
reads `Y((Y x)_{-j-1} y) = convOneSided (shiftedField x j) (Y y)` for an ARBITRARY `y` --- i.e. it IS
`IterateProductStep` (8.4.25) at every state, and `iterateProductStep_iff_forall_at` upgrades it.  Hence
**the Fock front is `FockCreatedStep E` ALONE** (equivalently the two-factor display), and
`PairFiniteAll`/`FockPairDatum`/`FockCreatedSpan` are **NOT inputs of Theorem 8.10.2** (this supersedes
NOTES 97.1/97.4, 99.4, and ROADMAP batch 200's "Fock = display + PairFiniteAll").  Batch 197-B's carrier
hypotheses are redundant: `coherentCreatedStep_of_twoOneSided` needs `hnd`/`hs` only, and
`fockCreatedStep_iff_createdStep_sharp` likewise.  The old route needed `hpair`+`hspan` only because it went
through the created states rather than through the `l = 0` slice.

The steered target landed the `l = 0` face at ALL states: `corollary851_lattice_canonical` (the lattice corner
at every pairing, canonical window), its lift `corollary851_lattice_of_canonical_le` to every `K`, the explicit
(8.5.4) `List.induction` (`stateOfVL_nil`/`_cons`, `corollary851_spanningStates_of_lattice_and_step`),
`corollary851_allStates_of_lattice_and_step` (arbitrary `Y`), and the compositions
`corollary851_allStates_of_residuals` / `corollary851_allStates_of_fockCreatedStep`.  The ONE remaining named
residual there is

```
def Corollary851ModeStep (Y) (K) : Prop := the two one-creation-mode steps
    C u v -> C (alpha_c(-r) u) v   and   C u v -> C u (alpha_c(-r) v),  r >= 1, at the SAME window K
```

--- the (8.6.4)--(8.6.27) one-mode fragment, NOT a restatement of the target.  Measured spellings: the window
side condition `hwin : forall a b, (-<a,b>).toNat <= K` must be explicit (`ResidueNegativeAligned` is per-pair
canonical-window), and the positive-pairing half of the corner exists only at the even cocycle, so the composed
theorems are at `C.toCentralExtension h2`; `hnd` is spent only by the Fock conjunct.

**Brief errors (batch 203).**  (A) (1) the target is not weaker than the residual; (2) the "mirror the positive
`ν = c-3` chamber" route cannot reach it (the positive theorems ARE the already-unconditional `ZLine` tower,
consumed as an IFF); (3) "`N >= 4` is the new content" is half right --- `N = 3` is equally open; (4) "largest
honest slice `N <= N0`" has no content inside `NegThreeChamberMomentForm`; (5) evenness is needed exactly for
`N = 1, 2`.  (B) (1) the Fock front is the display ALONE; (2) "what is missing is the actual two-factor
computation" is false as a reduction target (the `k = 2` display IS the one-step); (3) the carrier hypothesis of
`coherentCreatedStep_of_twoOneSided*` is redundant; (4) the requested `corollary851_of_residuals` shape is not
reachable as stated (the mode step is a third input); (5) Lean trap: stating the (8.5.4) induction with a literal
`List.foldr` in the goal blows the `whnf` budget --- state through `stateOfVL` with `rfl` unfolding lemmas and
`simpa only`, never `maxHeartbeats`.

**Accounting after batch 203**: `EvenCocycleResiduals` = `NegTwoFirstDerivZero` (LANDED) /\
`NegThreeExpandedResidualAligned` (= `NegThreeChamberMomentForm`, open) /\ `CoherentCreatedStep` (implied by
`FockCreatedStep` = the display, open).  `EvenCocycleJacobiStep`: (ii) DONE (batch 202), (i) reduced to
`Corollary851ModeStep` + the lattice corner, (iii) untouched.

---

### Batch 204 — 🏆 the `l = 0`, `<a,b> <= -3` residual IS PROVED at FLM's datum (all pairings, all N), and the Fock one-step is reduced to its shift-zero corner

**A — the residual, proved** (`Definitions/MMFLM86NegThreeProveAux.lean` 374 lines +
`Definitions/MMFLM86NegThreeProve.lean` 248 lines, namespace `MM.FLM86NTP`, 17 guards).  At
`E = C.toCentralExtension h2`, for every pairing and every `N >= 1`:

```
chamberMomentAtN_evenCocycle (C) (h2) (hs) (N) (hN1 : 1 <= N) : ChamberMomentAtN (C.toCentralExtension h2) N
negThreeAndBelowResidualAligned_evenCocycle   : FLM86NTR.NegThreeAndBelowResidualAligned (C.toCentralExtension h2)
negThreeExpandedResidualAligned_evenCocycle   : FLM86CF2.NegThreeExpandedResidualAligned (C.toCentralExtension h2)
negThreeChamberMomentForm_evenCocycle / allChamberMoment_evenCocycle
residueNegativeAligned_evenCocycle            : FLM86EPA.ResidueNegativeAligned (C.toCentralExtension h2)
```

The last is the WHOLE negative-pairing `Res_{z_0}` face, and the second is exactly the second conjunct of
`EvenCocycleResiduals`.  **Mechanism (the campaign's "hard residual" reading was wrong)**: `ChamberMomentAt` is
about the single antidiagonal family `M p = normOrdered2 E a b p (K-p) v`; the two chamber sums are its
half-lines `p >= N-m-1` and `p <= -m-1`, the moment sum is over all `p` with weight `C(p+m,N-1)`.  The landed
(8.4.21) transpose `MM.FLM86NOC.normOrdered2_transpose` supplies the factor `c(b,a)` on the second chamber, the
three (8.5.37) coefficient identities close the first, the second needs exactly `c(b,a) = (-1)^N`, and the gap
`-m <= p <= -m+N-2` carries the zero of the falling factorial
(`MM.FLM86R.binomCoeff_eq_zero_of_between`).  Finiteness is the LANDED per-antidiagonal window
`MM.FLM810NOC.assemblyDiagonal_antidiagonal` --- NOT `LocallyFinite2 normOrdered2`, which is refuted in
`MMFLM86InfSupp`.  **No Fock induction, no mode law, no anchor value, no spanning.**

Exact general-`E` gap, named: `CocycleAtPairing E a b N := E.c b a = (-1)^N` (a theorem at the even cocycle via
`EvenCocycle.c_eq_signPow` + `signPow_zmod_two_eq_zpow`), with the reduction
`chamberMomentAtN_of_cocycleSign`; the underlying SCALAR identity is proved BOTH ways
(`neg_mul_ratioCoeff_eq_iff : -c * ratioCoeff (-(N:Z)) k = binomCoeff (-(k:Z)-1) (N-1) <-> c = (-1)^N`).
"Evenness" is the wrong word: only the cocycle SIGN `c(b,a) = (-1)^N` is used (`N = 1` is refuted at a general
`E` by the landed rank-one counterexample; `N = 2` has a conditional obstruction; `N >= 3` neither proved nor
refuted at a general `E`).
**Bonus**: `antidiagonalCollapse_of_symmetricForm (hs) (E) : MM.FLM86NOC.AntidiagonalCollapse E` --- the `c`-free
`N = 1` collapse at a general `E`, composing the landed batch-181-A `MM.FLM86AR.assemblyDiagonal` with
`MMFLM86AntidiagonalAssembly.assemblyDiagonal_iff_collapse`.  Two stale file headers claiming
`AssemblyDiagonal`/`AntidiagonalCollapse` were "named, not proved" were corrected in place by the dispatcher.
**Withdrawal of record**: batch 203-A's recommendation "do NOT dispatch further prove-`NegThreeChamberMomentForm`
tasks" is WITHDRAWN --- the residual was provable and is proved; the chamber spelling is where it is easy.

**B — the Fock one-step at its sharpest** (`Definitions/MMFLM86FockOneStepProveAux.lean` 219 lines +
`Definitions/MMFLM86FockOneStepProve.lean` 306 lines, `MM.FLM86FOPA`/`MM.FLM86FOP`).

```
iterateProductStep_iff_level_zero (Y) (mul) (D) (hD) : IterateProductStep Y mul <-> IterateProductStepLevel Y mul 0
fockCreatedStep_iff_level_zero (hnd) (hs) (E) / fockCreatedStep_iff_shiftZero (hnd) (hs) (E)
display8610TwoOneSided_iff_shiftZero (hnd) (hs) (E) / coherentCreatedStep_of_shiftZero (hnd) (hs) (E)
```

with `FockShiftZeroStep E := forall x v, ZAligned E ((ZAligned E x) (-1) v) = convOneSided (ZAligned E x)
(ZAligned E v)` --- the `(j,l) = (0,0)` corner of (8.6.10), i.e. `Y(x_{-1}y) = Y(x)Y(y)`.  The engine is the
**`L(-1)` LADDER OF THE ONE-STEP**: the `j`-th level of (8.4.25) at `(x,v)` IS the level-zero statement at the
translated factor `(1/j!)L(-1)^j x`, because `((1/j!)L(-1)^j x)_{-1} = x_{-j-1}` and
`Y((1/j!)L(-1)^j x) = shiftedField Y x j` (iterated (8.10.13)).  The abstract form carries NO hypothesis on
`mul`, so it applies to the `dite` carrier `convOneSided`.  **New `hnd`/`hs`-free consequences**:
`coherentCreatedStep_of_twoOneSided_noHyp`, `fockCreatedStep_imp_coherentCreatedStep`,
`fockCreatedStep_imp_display8610One` (the one-step's vacuum slice IS the `k = 1` display, so the (8.10.13) input
is needed only to PROVE `display8610One_ZAligned` unconditionally, not to consume the residual), and
`fockCreatedStep_iff_createdStep` with NO hypotheses.

**Brief errors (B204-B).**  (1) The suggested mode-law/F-linearity induction does NOT close and is not needed:
the landed action laws (`MM.FLM86MLA.actionFamily_factorFactorZero_modeVL`, `actionFamily_modeVL_of_window`)
take the two-component commutator as a HYPOTHESIS on the accumulated field, and the Fock-level step would need
the commutator of two arbitrary honest modes --- the open Jacobi content.  The ladder bypasses it.
(2) "The `k = 1` display takes `hnd`/`hs`" is true of the PRODUCER, false of the consumer.
(3) The left-side expansion of `Y((Y x)_{-j-1} v)` exists only at lattice generators.
(4) The (8.5.5)-recursion induction on `v` is not the mechanism.
(5) `MM.FLM86MLA.actionFamily_factorFactorZero_modeVL` is not in the Fock front's import closure.

**Accounting after batch 204**: at FLM's datum `EvenCocycleResiduals` = `NegTwoFirstDerivZero` (LANDED) /\
`NegThreeExpandedResidualAligned` (**LANDED**) /\ `CoherentCreatedStep` (implied by `FockCreatedStep` =
`FockShiftZeroStep`, open).  Remaining for Theorem 8.10.2: the Fock shift-zero corner, `EvenCocycleJacobiStep`'s
(i) (`Corollary851ModeStep`, the all-states `l = 0` face) and (iii) (the passage from `Res_{z_0}` to (8.10.8)).

---

### Batch 205 — ⚠️ THE FOCK CORNER IS **REFUTED** at honest data (and FLM itself flags the identity as formal); the `l = 0` all-states face is exactly one mode step

**A — the refutation** (`Definitions/MMFLM86FockShiftZeroAux.lean` 398 lines + `Definitions/MMFLM86FockShiftZero.lean` 178 lines, `MM.FLM86FSZA`/`MM.FLM86FSZ`, 13 guards).  Machine-checked, spending **neither `hnd` nor `hs`**, and no evenness or cocycle input:

```
not_fockShiftZeroStep_of_gram (E) (i) (hgram : form (bL i) (bL i) != 0) : not (FockShiftZeroStep bL form E)
not_fockShiftZeroStep_rankOne   : not (FockShiftZeroStep (F:=Q) basisUnitInt (mul Z Z) (trivialCentralExtension Q Z))
not_fockCreatedStep_of_gram (hnd) (hs) (E) (i) (hgram) : not (FockCreatedStep bL form E)
not_display8610TwoOneSided_of_gram (hnd) (hs) (E) (i) (hgram) : not (Display8610TwoOneSided bL form E)
not_pairFiniteAll_of_gram / not_fockPairDatum_of_gram (E) (i) (hgram)
not_pairFinite_oneFactorState (E) (a) (hgram : form a a != 0)
```

**Mechanism.**  At `x = alpha_{b_i}(-1) iota(0)` (one oscillator on the vacuum), the (8.5.5) intertwining gives
`ZAligned E x k = modeVL (bL i) k` for `k != 0` (`yAligned_oneFactorState`, `zAligned_oneFactorState`).  Hence the
convolution summand at `(m,w) = (1, iota(0))` is `alpha_a(-j)(alpha_a(j) iota(0)) = ((-j).<a,a>).iota(0) != 0` for
EVERY `j <= -1` (landed `MM.FLM87ZBA2.modeVL_mul_modeVL_vacuum_self`), so no finite window exists:
`not PairFinite (ZAligned E x) (ZAligned E x)`, hence `convOneSided (ZAligned E x) (ZAligned E x) = 0`, while the
corner's left side is `ZAligned E u` for `u = (ZAligned E x)(-1)x = alpha_a(-1)alpha_a(-1)iota(0) != 0`
(monomial basis), against (8.5.23) `creationPropertyAligned`.

**This is exactly what FLM flags twice**: Remark 8.5.2 (printed p. 200) says (8.5.14) "is not rigorous in the
present setting", and Remark 8.6.4 (p. 211) says (8.6.28) is "formal but suggestive".  The honest identity at a
created state is the NORMAL-ORDERED `Y(u_{-1}v) = :Y(u)Y(v):`; the plain product differs by the contraction ---
which is the two-component commutator, here visible as a divergent convolution.

**What is NOT refuted**: `MM.FLM86CCS.CoherentCreatedStep E` --- the shape the boundary theorem actually consumes
(`EvenCocycleResiduals`'s third conjunct is `CoherentCreatedStep`, NOT `FockCreatedStep`).  Its two factors are
honest GENERATOR fields (the second shifted), its carrier is batch 182's
`pairFinite_shiftedField_ZAligned_iotaVL` for `0 <= <a,b>`, and the oscillator-carrying state above does not
occur in it; only `PairFiniteNegPairing` is open there.  Consequently `fockCreatedStep_imp_coherentCreatedStep`
is now VACUOUS, and `CoherentCreatedStep` needs a new producer: the GENERATOR SLICE of the display
(`Display8610TwoGenerators`-style, batch 185-A's `display8610TwoGenerators_iff_coherentForm`).

**B — the `l = 0` all-states face, exactly** (`Definitions/MMFLM86Corollary851ModeStepAux.lean` 363 lines +
`Definitions/MMFLM86Corollary851ModeStep.lean` 387 lines, 32 guards).  NOT proved, but pinned:

* `allStates_iff_corner_and_modeStep (Y) (K)` --- BOTH directions: given the corner (a theorem at FLM's datum
  since batch 204-A), `Corollary851ModeStep Y K` IS the whole remaining content of the `l = 0` face at all
  states.  (So batch 203-B's "one-mode fragment, not a restatement of the target" is misleading.)
* `corollary851_latticeFactor`: the corner extends, by the landed bilinearity, to the lattice factor
  `span{iota(a)}` --- the EXACT largest slice; the reading "bilinear + corner => one arbitrary argument" is
  FALSE.
* `residueOfField`/`FaceOf`, `corollary851_iff_faceOf`, `faceOf_zero`/`add`/`smul`, `faceOfSubmodule`,
  `corollary851_congr_field`: the face is a LINEAR CONDITION on the field `Y u`; and
  `modeStepLeft_iff_faceOf_closure`: the mode step's left half is exactly "the (8.4.16) action preserves the
  face submodule on the image of `Y`".
* `Yzero_modeVL_add`/`_smul`, `ZAligned_modeVL_add`/`_smul`: a one-mode descendant's field is linear in the
  state.  Named residuals: `Corollary851ModeStepOneMode`/`...Right`, `Corollary851CurrentFace`
  (`currentFace_iff_oneMode_zero`).
* **Exact residual**: expanding the action by (8.4.19) and the commutator by Leibniz leaves exactly the
  mode--field commutators `[alpha_c(e), ZAligned E v n]` at ARBITRARY `v`.  The landed action laws
  (`MM.FLM86MLA.actionFamily_factorFactorZero_modeVL`, `actionFamily_modeVL_of_window`) require that as
  `hcomm` and return it only up to a THIRD term `kappa . Yt.fam (m+r+n)`, so the two-component chain cannot be
  iterated.  (Dispatcher check: the landed `MM.FLM810CFC.currentFieldComm` is (7.1.5) at the repaired BASE field
  `baseRepaired E a` ONLY, so it does not supply the general-state commutator.)

**Ledger corrections of record (batch 205).**
(a) ROADMAP batch 203-B ("the Fock front is `FockCreatedStep` ALONE; the carriers are NOT inputs") and batch
204-B / NOTES 101.2 ("the front is the shift-zero corner") reduce to a FALSE target --- the carriers were NOT an
artefact.
(b) NOTES 97.1 and `MMFLM86FockCarrierAux` §2 ("negative pairing is the only place the datum can fail") are
REFUTED: `PairFiniteAll`/`FockPairDatum` are false as stated (they quantify over all states), and they fail at
oscillator-carrying states with `form a a != 0` for ANY pairing.
(c) NOTES 101.3's warning is confirmed and sharpened: the honest identity is the NORMAL-ORDERED one.
(d) Batch 205-B's correction to NOTES 100.3 (see above).
(e) Sections 93--96, 98, 99 (the `ZLine` tower, the `l = -c` faces, the `<= -3` residual) are untouched.

**Accounting after batch 205**: the boundary theorem's third residual is `CoherentCreatedStep` (as originally
defined); the honest Fock front is the GENERATOR slice of (8.6.10) (`Display8610TwoGenerators` /
`CoherentCreatedForm`), whose carrier is available for `0 <= <a,b>` (batch 182) and named as
`PairFiniteNegPairing` otherwise.  `EvenCocycleJacobiStep`: (ii) done; (i) = `Corollary851ModeStep` (=
the mode--field commutators); (iii) untouched.

---

### Batch 206 — the §8.6 engine's honest layer, and the generator slice's `(0,0)` corner is a THEOREM; the exact residuals are named

**A — the generator slice** (`Definitions/MMFLM86CoherentCreatedProveAux.lean` 167 lines +
`...Prove.lean` 361 + `...Residual.lean` 261, namespaces `MM.FLM86CCPA`/`MM.FLM86CCP`).

* **`createdStepAt_zero_zero`** --- the `(j,l) = (0,0)` instance of `CoherentCreatedStep E` at the lattice
  generators IS A THEOREM (symmetric `form`, `0 <= <a,b>`, and NO `hnd`):
  `ZAligned E (YFam E a (-1) iota(b)) = convOneSided (ZAligned E iota(a)) (ZAligned E iota(b))`.  Route:
  `ZAligned_mode_iotaVL` (left) + batch 182's carrier + (8.4.25) + the landed (8.4.20) `assemblyDiagonal` on
  each antidiagonal fibre + the scalar collapse `sum_{k<=N} ratioCoeff N k = (1-1)^N`.  So the generator slice is
  NOT dead at the corner.
* `coherentCreatedStep_iff_twoGenerators` / `<-> CoherentCreatedForm` (both directions, same hypotheses).
* `weightedAssemblyDiagonalZero_iff_assemblyDiagonal` (+ `weightedAssemblyDiagonalZero`): the `r = 0` slice of
  the new residual IS (8.4.20), both ways.
* `pairFinite_shiftedField_right_iff` (shift invisibility in the SECOND factor --- the mirror of batch 200-B,
  which shifts only the first), hence `shiftedPairFiniteGenerators_of_negPairing`
  (`PairFiniteNegPairing E -> ShiftedPairFiniteGenerators E`, the former explicit and never silent).
* **The exact residual: (WAD) = `WeightedAssemblyDiagonal E` at `r >= 1`**:
  `sum_{p+q=K} C(K-p, r) . normOrdered2 a b p (K-p) v = eps(a,b) . ZAligned E (E^-_b(z_0)_r iota(a+b)) (r-K-1) v`
  on a finite window.  Dictionary (derived in the headers, not yet formalized): at `j = 0`,
  `CreatedStepAt E a b 0 l <-> (WAD)` at `r = l-<a,b>`, `K = l-m-1-<a,b>`; `j >= 1` is the `L(-1)` ladder at
  the descendants of `iota(a)`; `<a,b> < 0` additionally needs `PairFiniteNegPairing`.

**Findings of record.**  `MM.FLM86CCS.createdStep_of_iterateProductStep` is **VACUOUS too** (its
`IterateProductStep` at `(x,0)` with base state `v := x` IS the refuted `FockShiftZeroStep`); NOTES §102.2's
"the oscillator-carrying state does not occur in it" holds only for the FACTORS --- the coherent base state
`creationExpVL b l (iota b)` IS oscillator-carrying for `l >= 1`, and what saves the slice is the carrier
(pairs of SHIFTED GENERATOR fields are finite for `0 <= <a,b>`) plus (WAD).  Ledger refinement:
`CoherentCreatedStep` is open only from `(j,l) != (0,0)`; the carrier alone is not the whole extra input for
`l >= 1`.

**B — the section 8.6 engine's honest layer** (`Definitions/MMFLM86Engine86.lean`, 405 lines, `MM.FLM86E86`,
22 declarations, `hnd` never spent, `hs` only in the two (8.4.21)/assembly theorems):

* (8.6.5) at the honest field: `series865` with `series865_zero`/`_succ`/`_one` and the dictionary to the landed
  `multiExpIdx`;
* the honest field at an ordinary power: `powerFam := YFam(-m-1)` with `powerFam_vacuum` and
  `powerFam_iotaVL : Y(a,w)_m iota(c) = E^-_a(w)_{m-<a,c>} iota(ac)` --- the EXACT pairing shift;
* (8.4.16) iterated: `splitFold` with `splitFold_zero`, `splitFold_one = Y(a,w)`,
  `splitFold_two = MM.FLM84.normalPair`, `splitFold_vacuum_one`;
* (8.6.10) at `k = 1`: `iteratedCreation_iotaVL` and `iteratedCreation_iotaVL_shift` (the exact shift --- this
  machine-checks batch 205's refutation mechanism), and on the vacuum the honest iterate IS the (8.6.5)
  coefficient;
* (8.6.6)/(8.6.8) at `k = 2` via the landed (8.4.20): `normOrdered2_vacuum_eq_series865` (the display's first
  equality on the vacuum, `eps(a,b)` explicit), `normOrdered2_swap_vacuum` ((8.4.21)), `assemblyDiagonal_vacuum`.

**The exact remaining gap: (8.6.6) for `k >= 3`** --- the `k`-fold middle family has NO carrier: (8.4.20) is the
nested TWO-variable Cauchy product (`convWith2` twice) and a `k`-variable nested carrier with local finiteness is
missing.  (8.6.8) reduces to it; (8.6.9)/(8.6.10) at general `k` are the landed open slices
(`IterateProductStep`, `Display8610TwoGenerators`, `CoherentCreatedStep`, `CoherentCreatedForm`); the
universally quantified plain-product spellings are REFUTED (batch 205) and only cited.  Passage (iii) was NOT
reached (it needs the `k >= 3` carrier first).

**Corrections of record (B206-B).**  (a) (8.6.5) and `kFoldNormalOrder` were ALREADY landed (batch 119:
`MMFLM86MultiState` 651 lines, `MMFLM86KFold` 880; ROADMAP:5013-5015 / NOTES:1055-1056 --- and ROADMAP:4679 is
STALE).  (b) `kFoldNormalOrder` is NOT (8.6.6)'s middle family for `k >= 2` on honest lattice fields (its mode
splitting includes the field's `E^+` half); only `normOrdered2` is.  (c) Remark 8.6.4 (p. 211) displays the
PLAIN product (8.6.28) and calls it "formal but suggestive"; the normal-ordered form is batch 205's repair, not a
quotation.  (d) The `iota`-shifts belong to (8.5.11), not to the shift-free (8.6.5).  (e) Section 8.6 has no
associativity law for the `k`-fold normal-ordered product; only (8.4.21) symmetry, landed here for `k = 2`.

**Accounting after batch 206**: `CoherentCreatedStep` open only from `(j,l) != (0,0)`, residual (WAD) at
`r >= 1`; the §8.6 route (iii) needs the `k >= 3` nested Cauchy carrier; item (i) = `Corollary851ModeStep`
(the mode--field commutators); `NegTwoFirstDerivZero`, `NegThree*`, `ResidueNegativeAligned`, the `l = -c`
faces and the `ZLine` tower are all THEOREMS.

---

### Batch 207 — the `k`-variable nested Cauchy carrier is BUILT ((8.6.6)/(8.6.8) at general `k`), and the Fock residual's `j = 0` face is pinned by a formalized dictionary

**A — the Fock residual's `j = 0` face** (`Definitions/MMFLM86WeightedAssemblyAux.lean` 441 lines,
`MM.FLM86WAA` + `Definitions/MMFLM86WeightedAssembly.lean` 507 lines, `MM.FLM86WA`).

* `WeightedAssemblyAt E a b r` (the `r`-weighted antidiagonal assembly) and `weightedAssemblyAt_zero`: the `r = 0`
  slice IS the landed (8.4.20), so the residual's content is exactly `r >= 1`.
* **THE DICTIONARY, BOTH DIRECTIONS** (`hs` symmetric, `0 <= <a,b>`, `l >= <a,b>.toNat`):
  `createdStepAt_zero_iff_weightedAt : CreatedStepAt E a b 0 l <-> WeightedAssemblyAt E a b (l - <a,b>.toNat)`,
  the `r`-form `weightedAssemblyAt_iff_createdStepAt_zero`, the GAP theorem `createdStepAt_zero_of_lt`
  (`l < <a,b>.toNat` gives `0 = 0`), and the global positive-pairing equivalence.  Hence **(WAD) at `r >= 1`
  IS the `j = 0` face of the Fock residual** --- nothing else is missing there.
* Aux core (new): the previously-unlanded GAP case of the shifted weight sum
  (`sum_ratioCoeff_mul_binomCoeff_shift_of_lt`), the regrouping of the shifted convolution onto the antidiagonal
  (`convSumOS_shifted_eq_sum_ratioCoeff`), its collapses `convSumOS_shifted_eq_weighted` /
  `convSumOS_shifted_eq_zero`, and the `j = 0` left-hand side `zAligned_zeroMode_creationExpVL`
  (from batch 184-B's `ZAligned_createdState`).

**Brief errors of record (B207-A).**  (1) The dictionary needs `l >= <a,b>.toNat` and its global form lives on the
POSITIVE-pairing face --- the brief's implied global equivalence is FALSE for `<a,b> < 0` (and the
negative-pairing face needs `PairFiniteNegPairing` AND an expansion of its own).  (2) The collapse needed is the
created-state orientation `sum_ratioCoeff_mul_binomCoeff_shift` PLUS its new gap case, NOT the batch-203/204
moment machinery (opposite orientation).  (3) Most of the "material to #check" list is not on the path:
`ZAligned_createdState` at `j = 0` plus `weightedAssemblyDiagonalZero` suffice.  (4) The ladder/consumer route
(`MM.FLM86FOPA.iterateProductStep_iff_level_zero`) is DEAD for the consumer: it reduces level `j` to level 0 at
the TRANSLATED factor `(1/j!)D^j a`, a DESCENDANT of `iota(a)` and not a lattice generator, so the dictionary
(whose inputs are theorems only at generator fields) cannot consume it.  `j >= 1` stays open.

**B — the `k`-variable nested Cauchy carrier** (`Definitions/MMFLM86NestedCauchyAux.lean` 455 lines +
`...NestedCauchy.lean` 462 + `...NestedCauchyTwo.lean` 361 + `...NestedCauchyAxioms.lean` 314 (73 axiom guards),
namespace `MM.FLM86NCA`/`MM.FLM86NC`).

* the carrier `MultiVar F L k = (Fin k -> Z) -> End_F(V_L)`, `LocallyFiniteK`, `convWithK` with
  window-independence, proof-irrelevance and bilinearity; `famFold` and **`locallyFiniteK_famFold`** (the nested
  finiteness, by induction: tail window, then the outer factor's window on each surviving state);
* dictionaries: `convWithK_two` (`k = 2` IS `MM.FLM86TN.convWith2` up to `(Z x Z) ~ (Fin 2 -> Z)`) and
  `convWithK_one` (`k = 1` IS `MM.FLM85CP.convWith` under `m -> -m-1`);
* `blockScalarK` (the iterated (7.1.28) cocycle; `blockScalarK E 2 ![a,b] = E.eps a b`), `actProd`,
  `creationPairK`/`midBlockK`/`annihPairK`, `normOrderedK`, and **(8.6.6)/(8.6.8) at general `k`**:
  `normOrderedK_vacuum (E) (k) (as) (r) : (normOrderedK bL form E k as (fun i => (r i : Z))) vacuumVL
  = blockScalarK E k as . series865 bL form k as (sum i, as i) r` and `normOrderedK_vacuum_B` (verbatim
  (8.6.8));
* the specialisations: `normOrderedK_one = MM.FLM86E86.powerFam` (all states),
  `normOrderedK_two = MM.FLM86TN.normOrdered2`, `normOrderedK_two_vacuum_eq_series865` (recovers batch 206-B's
  `k = 2` theorem verbatim) and `normOrderedK_swap_two` ((8.4.21) at `k = 2`).

**Key finding**: the local-finiteness input is **DISCHARGEABLE from landed material** --- no
`NestedLocallyFinite` residual exists anywhere; `locallyFiniteK_famFold` proves the joint finiteness of any
ordered product of one-variable locally finite families (`exists_zPowHVL_eq_zero`,
`locallyFiniteCoef_annihFam`), so `midBlockK` and `annihPairK` are `k`-variable locally finite AS THEOREMS;
only `creationPairK` is not (the landed `MM.FLM86IS.creationPair2_not_locallyFinite2`), which is exactly
(8.4.20)'s nesting.  The brief's conditional fallback did not arise.

**Still open in the §8.6 route**: (8.6.6)'s SECOND equality, i.e. the pairing-factor family
`prod_{i<j}(w_i-w_j)^{-<abar_i,abar_j>}` (still the landed batch-119 `MM.FLM86KF.Display866Family3` plus the OPE
(8.4.22)/(8.4.36)); and no general-`k` symmetry/associativity was invented (FLM states (8.4.21) for two factors
only).

**Supersessions**: NOTES §103.2 / ROADMAP batch 206's "the exact remaining gap is the `k >= 3` nested Cauchy
carrier" is STALE (the carrier is built and (8.6.6)/(8.6.8) are proved at general `k`); batch 206-B's header
claim that the `k`-fold normal-ordered product "is not an object of this repository" is FALSE (it is
`MM.FLM86NC.normOrderedK`); NOTES §103.4's `(8.6.6)_{k>=3}` row is a THEOREM now.

**Accounting after batch 207**: the Fock residual is (WAD) at `r >= 1` (equivalently `CreatedStepAt(0,l)` at the
generators), plus the `j >= 1` face and the negative-pairing dictionary; the §8.6 route's next step is (8.6.6)'s
second equality; item (i) is `Corollary851ModeStep`; (iii) untouched.

---

### Batch 208 — 🎯 (WAD) IS A THEOREM at every weight (the Fock residual's `j = 0` face closed at `0 <= <a,b>`), and (8.6.6)'s second equality is stated at general `k` with its `k <= 2` slices proved

**A — the tower read backwards** (`Definitions/MMFLM86WeightedAssemblyAll.lean`, 339 lines, `MM.FLM86WAB`,
10 guards).

```
weightedAssemblyAt_of_one_le (hs) (E) (a b) {r} (hr : 1 <= r) : WeightedAssemblyAt E a b r   -- NO pairing hypothesis
weightedAssemblyAt_all (hs) (E) (a b) (r) : WeightedAssemblyAt E a b r
weightedAssemblyDiagonal_all (hs) (E) : WeightedAssemblyDiagonal E     -- the batch-206 residual, DISCHARGED
createdStepAt_zero_of_nonneg (hs) (E) (a b) (hN : 0 <= form a b) (l) : CreatedStepAt E a b 0 l
coherentCreatedStep_iff_of_pos_zero_face (hs) (E) :
    CoherentCreatedStep E <-> CreatedStepAtZeroNegPairing E /\ CoherentCreatedStepPos E
```

**Route**: the UNCONDITIONAL `zLine_all` (batch 202) read at the TRANSPOSED pair `(b,a)`, order `r`, scheme
parameter `n = r-K-1` --- the scheme's diagonal degree is then identically `K`, so the brief's "index
renormalisation `K <-> K'`" is VACUOUS; reindex `p |-> K-p`; `MM.FLM86NOC.normOrdered2_transpose` ((8.4.21))
moves the weight `C(p,r)` to the SECOND index as `C(K-p,r)` and contributes `c(b,a)^-1`;
`MM.FLM86CF2.creationExpVL_anchorVL` ((7.1.20)+(7.1.28)) expands the anchor giving `eps(b,a)`; and
**(7.1.26) `MM.FLMLattice.CentralExtension.eps_mul_comm`** cancels `eps(b,a) = c(b,a).eps(a,b)`.  NO even-cocycle
hypothesis, NO `PairFiniteNegPairing`, NO positivity.  **The decisive content is the weight ORIENTATION**
(`momentSum` weights the first index, (WAD) the second) --- which is exactly why the statement lands in the
`diagSum`/transpose shape rather than a `ZLineAt` shape.  `MM.FLM86NTR.ZAligned_anchorVL` is NOT on the path.

**B — (8.6.6)'s second equality, stated and sliced** (`Definitions/MMFLM86Display866TwoAux.lean` 432 lines +
`...Two.lean` 297 + `...TwoAxioms.lean` 128 (36 guards), `MM.FLM86D866A`/`MM.FLM86D866`).

* the two spellings of the second equality as Props at EVERY `k` (`Display866SecondEqK`, `Display866BoxK`;
  each carries `hs` and `forall p : PairIdx k, 0 <= pairC form k as p` as EXPLICIT binders) and their equivalence
  BOTH ways (`display866SecondEqK_iff_boxK`, via the new regrouping `pairSum_eq_pairFamK_sum`);
* the slices as THEOREMS: `display866SecondEqK_one`, `display866SecondEqK_two` (`k = 2` consumes the landed
  `MM.FLM86YP.YFam_mul_apply_eq_sum_ratioCoeff`, i.e. the landed (8.4.22)/(8.4.25));
* the composition with the landed first equality: `display866Display_of_second` gives (8.6.6) as FLM states it
  (third family = `series865` times the pairing factor), with `hpair` explicit;
* new auxiliaries: `ordFamK` (the honest ordinary-product coefficient family), the (8.6.7) combinatorics
  `pairSetK`/`pairWeightK`/`pairShiftK`/`pairFamK`/`pairBoxK` with their `k = 2` dictionaries, and
  `normOrderedK_vacuum_eq_zero_of_neg` (the middle family is a power series --- needed for the Nat-indexed
  display form).

**Residual: `Display866SecondEqK` at `k >= 3`** --- the general-`k` OPE/insertion step (one honest field against
a `k`-fold normal-ordered product), i.e. the `k >= 3` case of (8.4.22)/(8.4.36); only the one-pair case is landed
and `MMFLM86Contraction8612`'s `Contraction8612Ratio` is open even at `k = l = 1`.  NOT covered: the
negative-pairing face (every statement carries `0 <= <abar_i,abar_j>` --- load-bearing, since `pairSetK` truncates
for negative `c`), the Laurent spelling of the printed `(w_i-w_j)^{-<a,b>}` (only the rearranged positive-exponent
polynomial form over `Nat^k` is formalizable), and (8.6.9)/(8.6.10)/Jacobi.

**Corrections of record (B208-B).**  (1) The landed batch-119 `MM.FLM86KF.Display866Family3` has a DEGENERATE
scalar shape over families `Fin k -> Nat -> VL` and CANNOT carry the second equality --- the honest carrier is
batch 207's `MM.FLM86NC.normOrderedK`, so the target had to be stated fresh (NOTES §104.2's first half is stale).
(2) The `k = 2` OPE lives in `MM.FLM86YP` (`YFam_mul_apply_eq_sum_ratioCoeff`), not in
`MMFLM86OPEThird`/`ExpProduct`/`Harvest`.  (3) `MM.FLM86E86` is a namespace, not a file.  (4)
`0 <= <abar_i,abar_j>` is load-bearing (a first version contained the FALSE `pairSetK.Nonempty <-> 0 <= c`).
(5) Composing with `normOrderedK_vacuum` needs `normOrderedK_vacuum_eq_zero_of_neg`.
**Discipline note**: the `sorryAx` trap FIRED LIVE once in this batch (a stale proof body silently became
`sorryAx`, caught only by the `#guard_msgs` diff) --- the campaign's guard+probe discipline is load-bearing.

**Accounting after batch 208**: the Fock residual is exactly
`CreatedStepAtZeroNegPairing E /\ CoherentCreatedStepPos E` (both open, both named, equivalence both ways); route
(iii)'s next step is `Display866SecondEqK` at `k >= 3`; item (i) is `Corollary851ModeStep`.

---

### Batch 209 — ⛔ THE FOCK RESIDUAL IS **REFUTED** AS SPELLED (two independent machine-checked routes): the honest slice is `0 <= <a,b>`

**A — the `j >= 1` face, falsified** (`Definitions/MMFLM86CoherentCreatedPosAux.lean` 161 lines +
`...PosRankOne.lean` 361 + `...Pos.lean` 283).

* `zAligned_createdStep_left_zero` --- the residual's left-hand side at `l = 0` evaluated UNCONDITIONALLY by the
  landed `MM.FLM86MI.ZAligned_mode_iotaVL`:
  `ZAligned E (YFam E a (-(j:Z)-1) (creationExpVL b 0 (iotaVL b)))
  = E.eps a b . (if 0 <= (j:Z) - form a b then ZAligned E (creationExpVL a ((j:Z)-form a b) (iotaVL (a+b))) else 0)`,
  nonzero for `a != 0` and `form a b <= (j:Z)` (`zAligned_createdStep_left_zero_ne_zero`).
* `pairFinite_of_createdStepAt` --- the face IMPLIES the pair datum (the right-hand side is 0 where the datum
  fails: `MM.FLM86TFD.convOneSided_eq_zero` + `MM.FLM86FCA.pairFinite_shiftedField_iff`).
* the rank-one counterexample: `YFam_rankOne_summand` (`YFam formZ extZ 1 (k:Z) (vk k) = extZ.eps 1 (-1) . vacR`
  for EVERY `k >= 0`, engine: `MM.FLM86CT.YFam_eq_sum_three_factor_of_mem` + `annihFam_apply_creationFam` +
  `annihFam_iotaVL`/`midFam_iotaVL`), hence `not_pairFinite_rankOne`, `not_createdStepAt_rankOne`,
  `not_coherentCreatedStepPos_rankOne`.
* the corrected slices: `CoherentCreatedStepPosNonneg` (`0 <= <a,b>`), `CoherentCreatedStepPosNegPairing`
  (named FALSE face), `coherentCreatedStepPos_iff_nonneg_and_neg`, `CoherentCreatedStepNonneg`,
  `coherentCreatedStepNonneg_iff_posNonneg` (at `0 <= <a,b>` the residual is exactly its `j >= 1` face, the
  `j = 0` face being batch 208-A), and `coherentCreatedStep_iff_slices`.
* the GENERAL refutations `not_createdStepAt_of_neg_pairing`, `not_coherentCreatedStepPos_of_neg_pairing`
  (consuming the sibling's carrier failure).
* `CoherentCreatedStepPosPairingFactor` --- the NAMED honest negative-pairing replacement (the threshold form of
  (8.4.22)/(8.4.25), `MM.FLM86RX.threshold_holds`, valid at every pairing per `(p,q)` and per state; matches the
  landed `MM.FLM86MXP.Display8625One` at `k = l = 1`), STATED not proved, with the coupling of the outer window
  to the single threshold `T` flagged as unverified.

**B — the `j = 0` negative-pairing face, falsified** (`Definitions/MMFLM86CreatedStepNegAux.lean` 277 lines +
`...CreatedStepNeg.lean` 315).

* **THE KEY IDENTITY** `yFam_creationExpVL_iotaVL`:
  `YFam E a (-<a,b> + q - 1) (creationExpVL b q (iotaVL b)) = ratioCoeff <a,b> q . (eps(a,b) . iotaVL (a+b))`
  --- at `<a,b> = -N < 0` this is `C(N+q-1,q).eps.iota(a+b) != 0` for EVERY `q` (at `q = 0`, `N = 2` it
  reproduces the landed `twoVarField_rankOne_negTwo_zero_vacuum`, a self-check);
* `not_pairFinite_generators_of_neg`, `not_pairFiniteNegPairing_of_exists_neg`,
  `not_pairFiniteNegPairing_rankOne`, `createdStepAtZeroNegPairing_imp_pairFiniteNegPairing`,
  `convOneSided_generators_neg_eq_zero`,
  `createdStepAt_zero_neg_iff_field_eq_zero` (the face is exactly "an honest field of a NONZERO state vanishes"),
  `not_createdStepAtZeroNegPairing_of_exists_neg`, **`not_coherentCreatedStep_of_exists_neg`**, and
  `not_shiftedPairFiniteGenerators_of_exists_neg` (batch 197-B's carrier is false too).

**Mechanism.**  The formalised right-hand side is the PLAIN one-sided product; FLM's rigorous (8.6.25)/(8.6.27)
carries the PAIRING FACTOR `prod (z_0 + w_i - x_j)^{<a_i,b_j>}`, which vanishes on the diagonal IFF
`0 <= <a,b>`.  For `<a,b> < 0` the contraction `(z-w)^{-N}` has infinitely many diagonal terms,
`convOneSided` falls into its 0 branch, and the face asserts that a nonzero field is 0.  This is exactly what FLM
flags in Remark 8.5.2 (p. 200) and Remark 8.6.4 (p. 211).

**Refuted record.**  Batch 200-B's numerical note ("the summand is a diagonal extraction and cancels") is WRONG
--- it cancels in FOCK DEGREE, not in `j`.  NOTES §97.1's `PairFiniteNegPairing` row, and batch 208/§105.3's
accounting ("Fock residual = `CreatedStepAtZeroNegPairing` /\ `CoherentCreatedStepPos`, both open") must read:
the first conjunct is FALSE, the second moot; §105.1/§105.3's "open everywhere including `(0,0)`" is stale.

**Consequence for the campaign.**  `CoherentCreatedStep` --- the third conjunct of
`MM.FLM810TE.EvenCocycleResiduals` --- is FALSE at FLM's own Leech datum (`a = x`, `b = -x`), so that residual
is FALSE as stated, NOT open, and `theorem8102_of_residuals` is **VACUOUS**.  The boundary reduction must be
re-stated with the honest residual.

**Untouched** (they use `normOrdered2`, not `convOneSided`): the `l = -c` faces, `ResidueNegativeAligned`,
`NegTwo*`, `NegThree*`, and the whole `ZLine` tower.

**Honest overlap**: A's rank-one file is a self-contained special case (kept); its two general corollaries consume
B's theorem rather than reproving it.  Two independent routes to a critical refutation is the right outcome.

**Still open**: `CoherentCreatedStepPosNonneg E` (the honest residual at `0 <= <a,b>`; the tower closes at most
its `l = 0` slice --- the `j >= 1` convolution has the double-binomial weight
`sum_i ratioCoeff <a,b> i . C(p+N-i,j) . C(K-p+i,l)`, which collapses to the tower's `C(p, j-<a,b>)` only at
`l = 0`), and the named honest negative-pairing replacement `CoherentCreatedStepPosPairingFactor`.

---

### Batch 210 — the audit, the honest re-statement of the boundary, and the positive-pairing Fock residual reduced to ONE named statement

**A — the honest Fock residual, reduced** (`Definitions/MMFLM86CoherentCreatedNonnegAux.lean` 430 lines +
`...Nonneg.lean` 309, `MM.FLM86CCNA`/`MM.FLM86CCN`).

* **`createdStepAt_shiftZero`** --- for a symmetric form and `0 <= <a,b>`, `CreatedStepAt E a b j 0` for EVERY
  `j : Nat` (spending ONLY `hs`; no `hnd`, no evenness).  This is FLM (8.5.14) --- the display that Remark 8.5.2
  (printed p. 200) calls "not rigorous in the present setting" --- read at the `z_0^j`-coefficient, i.e. the
  `w_2 = 0` case of (8.6.10) at `k = 2`.  Route: batch-182 carrier -> finite `convSumOS` -> per-summand shifted
  (8.4.25) -> antidiagonal regrouping with the double-binomial weight
  `sum_i ratioCoeff N i . C(K-q+N-i, j)`, `K = j-1-m-N` -> the REFLECTED (8.5.37) finite difference collapses it
  to `C(P, j-N)` (and to 0 in the gap `j < N`) -> the landed tower `ZLine E (j-N)` (order 0 = the (8.4.20)
  assembly), with the left side by `YFam_iotaVL_eq_exp` (8.5.11).  So the tower closes the `l = 0` face at EVERY
  `j` --- ROADMAP batch 209's route note is confirmed and sharpened.
* **THE ONE NAMED RESIDUAL**: `MM.FLM86CCN.CoherentCreatedStepShifted E := forall a b, 0 <= form a b -> forall j,
  1 <= j -> forall l, 1 <= l -> CreatedStepAt E a b j l` (the genuine two-shift (8.6.10) at `k = 2`, `w_2 != 0`),
  with the reductions BOTH ways: `coherentCreatedStepPosNonneg_iff_shifted`,
  `coherentCreatedStepPosNonneg_iff_shiftZero_and_shifted` (the `l = 0` slice is DERIVED, nothing is lost), and
  `coherentCreatedStep_iff_shifted_slices` (the whole `CoherentCreatedStep` = this face /\ the two
  negative-pairing faces that batch 209 refuted).
* Why `l >= 1` differs (paper computation, NOT formalized): the general inner weight is
  `sum_i ratioCoeff N i . C(q+i,l) . C(P+N-i,j)` --- the extra `C(q+i,l)` kills the single finite difference;
  hand-checked at `(N,j,l) = (2,1,1)` where the inner sum is the nonzero constant `-2`.

**B — the audit and the honest boundary** (`Definitions/MMFLM810HonestLedger.lean` 256 lines +
`...HonestAudit.lean` 433 + `...BoundaryHonest.lean` 369, `MM.FLM810HL`/`MM.FLM810HA`/`MM.FLM810BH`; 55 guards).

* **The old package is FALSE, not open**: `not_evenCocycleResiduals_of_gram`,
  `not_evenCocycleResiduals_of_posDef` (false already at `PositiveDefinite` + one nonzero vector --- no Leech
  appeal needed), `theorem8102_of_residuals_vacuous`, `not_coherentCreatedStep_of_gram`, plus the consumer
  killers `not_fockCreatedStep_of_gram`, `not_iterateProductStep_of_gram`, `not_display8610TwoOneSided_of_gram`,
  `not_shiftedPairFiniteGenerators`, `not_pairFiniteNegPairing`, `not_pairFiniteAll_of_gram`,
  `not_fockPairDatum_of_gram`, `not_createdStepAtZeroNegPairing`, and per-consumer vacuity theorems for
  `coherentCreatedStep_of_fockCreatedStep`, `fockCreatedStep_imp_coherentCreatedStep`,
  `coherentCreatedStep_of_twoOneSided_noHyp`/`_of_twoOneSided`, `createdStep_of_iterateProductStep`,
  `corollary851_allStates_of_fockCreatedStep`, `evenCocycleResiduals_of_fockCreatedStep`,
  `residueNegativeAligned_evenCocycle_of_residuals`.
  NOTE: `residueNegativeAligned_evenCocycle_iff_residuals` is an EQUIVALENCE whose right side is false --- VALID,
  not vacuous; the Fock-free reading of record is `residueNegative_iff_negTwo_and_negThree`.
* **The honest package**: `FockResidualHonest E := CoherentCreatedStepPosNonneg E /\
  CoherentCreatedStepNegPairingFactor E /\ CreatedStepAtZeroNegPairingHonest E` ->
  `EvenCocycleResidualsHonest` -> `EvenCocycleJacobiStepHonest` ->
  **`theorem8102_of_residuals_honest`**.
* **Non-vacuity PROVED**: `evenCocycleResidualsHonest_iff : (forall a b, 0 <= form a b) ->
  (EvenCocycleResidualsHonest C h2 <-> EvenCocycleResiduals C h2)` --- on the whole slice where batch 209 does not
  apply, the honest hypothesis says exactly what the old one said, and its two negative-pairing conjuncts are
  theorems there (`negPairingFactor_of_forall_nonneg`, `zeroNegPairingHonest_of_forall_nonneg`,
  `fockResidualHonest_iff_of_forall_nonneg`, `posNonneg_of_coherentCreatedStep`).
* **The ONE new named object**: `CreatedStepAtZeroNegPairingHonest` --- the missing normal-ordered ONE-VARIABLE
  product at the shifted coherent state, stated WITH the (8.6.25) threshold spelling (without that clause the def
  is provable by `prod := LHS`, i.e. a silent drop --- the agent checked this).  The tree has no such object:
  `MMFLM86YP` section 6(ii) records that `convWith (YFam E a) (YFam E b)` does not exist and `YFam` is not a
  `CField` for `a != 0`.

**Status changes of record.**  NOTES §105.1/§106.5's "the `j >= 1` face is open everywhere including `(0,0)` with
NO producer in the tree" is STALE --- `l = 0` producers now exist for every `j`; the row for
`CoherentCreatedStepPosNonneg` should read "open in its `w_2 != 0` face only, equivalent to
`CoherentCreatedStepShifted` (both ways)".  The stale claim in `MMFLM86FockShiftZero.lean`'s header that
`CoherentCreatedStep` "remains open" was corrected in place by the dispatcher (batch 209 refuted it).
**Brief errors (B210-A).**  (1) `Finset.not_mem_empty` does not exist in this pin (it is `Finset.notMem_empty`);
(2) `Int.toNat_of_nonneg` must not be used as a right-to-left rewrite on goals containing `(form a b).toNat`;
(3) `ZLine`'s value lives in the `FLM810JZF.ZAligned` copy while `CreatedStepAt` uses `FLM810JF2.ZAligned`, and
`MM.FLM86MI.ZAligned_JZF_eq` is not in the import cone of NEW files (re-proved privately);
(4) the `L(-1)` ladder is unusable (its universal level-0 premise is refuted);
(5) the empty window is NOT a legal regrouping window in the gap `j < N`;
(6) the `#guard_msgs` wrap is empirically name-dependent.

**Accounting after batch 210**: the honest boundary reduction is landed and non-vacuous on the positive-pairing
slice; the Fock residual's positive face is `CoherentCreatedStepShifted` (= the two-shift `l >= 1` case), its
negative-pairing face needs the to-be-built object; `(i)` = `Corollary851ModeStep`; `(iii)` =
`Display866SecondEqK` at `k >= 3`.

---

### Batch 211 — 🎯 the two-shift Fock face is PROVED from ONE derivation identity, and the negative-pairing object is BUILT (with two defects of record in batch 210-B's spelling)

**A — `CoherentCreatedStepShifted` proved** (`Definitions/MMFLM86ShiftedDerivAux.lean` 208 lines, `MM.FLM86SDA`;
`...ShiftedDeriv.lean` 215, `...ShiftedBootstrap.lean` 309, `MM.FLM86SD`).

```
coherentCreatedStepShifted_of_derivation (hnd) (hs) (E) (hder) : CoherentCreatedStepShifted bL form E
coherentCreatedStepPosNonneg_of_derivation (hnd) (hs) (E) (hder) : CoherentCreatedStepPosNonneg bL form E
```

(the second through the landed `MM.FLM86CCN.coherentCreatedStepPosNonneg_iff_shifted`).  The ONE named residual is

```
MM.FLM86SD.ShiftedCreationDerivation (hnd) E : Prop :=
  L(-1)(alpha_a(-n) w) = alpha_a(-n)(L(-1) w) + n . alpha_a(-n-1) w      -- all n >= 1, ALL states w
```

--- the (8.4.14)/(7.1.41) derivation identity, i.e. the tree's open `MM.FLM810TG.LMinusOneCreationMode` /
`MM.FLM810DFA.SugawaraDerivation` (only its GENERATOR case `w = iota(c)` is landed:
`MM.FLM810TG.lMinusOneCreationMode_iota`).  **Route**: `E^-_b(l) iota(b) = (1/l!).L(-1)^l iota(b)`, so the
two-shift face is the shift-ZERO tower (batch 210-A's `createdStepAt_shiftZero`) plus the `L(-1)` LADDER:
differentiate the level-`l` statement, use the NEW Leibniz rule `MM.FLM86SDA.coefDeriv_convOneSided` and
`coefDeriv (shiftedField a j) = (j+1).shiftedField a (j+1)` (8.6.9), and the derivation property at mode
`-(j+1)` cancels the `(j+1).(Y a)_{-j-2} B_l` term against the level-`j+1` shift-zero statement.
**The double-binomial weight is never formed** --- batch 210-A's obstruction is bypassed entirely.
**Caveats of record**: `hnd` IS spent (contrary to the brief's expectation --- `L(-1)` goes through the
conformal vector, so (8.10.13) and the `k = 1` display carry it); the identification of the residual with
`LMinusOneCreationMode` is a READING across two currencies, NOT a formal bridge; the next step is the
creation-list induction from `lMinusOneCreationMode_iota` (template:
`MMFLM810DFA.translationResidual_of_baseResidual`).
**Falsification check** (run first, no counterexample): rank-one, `a = b = 1`, `m = -1`, vacuum; it confirmed
batch 210-A's obstruction (weight `2q-2` at `(2,1,1)`) and produced the two-term collapse identity
`sum_i ratioCoeff N i C(q+i,l)C(P+N-i,j) = sum_a (-1)^(N-a)C(N,a)C(q,l-N+a)C(P,j-a)` (from
`[t^l s^j](1+t)^q(1+s)^P(s-t)^N`), specialising to both landed collapses --- not needed by the working route.

**B — the negative-pairing object, built** (`Definitions/MMFLM86NormOrderedShiftedAux.lean` 391 lines,
`MM.FLM86NOSA` + `...Shifted.lean` 294, `MM.FLM86NOS`).

* **THE OBJECT**: `pairBlock E a b j l m T` --- the (8.6.25)/(8.6.27) block sum at the shifted coherent state with
  the pairing factor carried as `ratioCoeff` on the window `q in Icc (-T-1,-1)`, `k in range (T+1)`.  Laws:
  unfolding; bilinearity in the state; the `(z_1-z_2)^{<a,b>}` factor explicit
  (`contrFam_eq_ratioCoeff_smul_one`, `ratioCoeff_eq_pow_mul_binom`); the null pair collapsing to a SINGLE
  normal-ordered block (`pairBlock_of_form_eq_zero`); the vacuum and generator specialisations; the inner `k`-sum
  identified with the landed (8.4.25) at `0 <= <a,b>` (`twoVarField_eq_ratioSum_of_nonneg`); and
  `convOneSided_shifted_eq_ratioSum` --- the carrier's own summands ARE the two shift binomials against
  `twoVarField`, which is where the pairing factor lives and **where the second slot index `l` comes from**.
* **The two faces reduced to one named input EACH, BOTH ways**: `HonestNegPairingZero E` (<-> the corrected
  `CreatedStepAtZeroNegPairingHonestCorrected`) and `HonestNegPairingPos E`
  (<-> `MM.FLM810BH.CoherentCreatedStepNegPairingFactor`); plus `FockResidualHonestCorrected` and
  `fockResidualHonestCorrected_iff_of_forall_nonneg` (the corrected package IS the batch-210 package on the
  `0 <= <a,b>` slice).
* **TWO DEFECTS OF RECORD in batch 210-B's spelling** (found by the mandatory falsification check):
  (a) **machine-checked**: `CreatedStepAtZeroNegPairingHonest`'s clause (b) writes the SECOND shift binomial with
  index `0`, while the landed carrier (`shiftedField_apply`) carries index `l` --- at `l = 1, q = -2` those are
  `C(2,1) = 2` vs `C(2,0) = 1` (`MM.FLM86NOSA.pairBlock_slot_discrepancy`), so the def is NOT the `j = 0` slice
  of slice 2, contrary to its own docstring;
  (b) **exact hand computation**: the SINGLE threshold `T` is too small --- at `w = iota(1)`, `m = -1`, `l = 1`,
  `<a,b> = -M < 0` the `b`-degree-1 blocks force `T = 0`, at which the `b`-degree-0 block is missing; the honest
  (8.6.25) spelling needs a threshold PER SHIFT INDEX (outer AND inner).  This upgrades NOTES §106.3's own
  "coupling ... flagged unverified" to "**wrong as spelled**".  The dispatcher recorded the defect in the def's
  docstring (pointing at the corrected package); the defs themselves were NOT weakened.
* **Still missing to close the two faces**: the **h-weight (Fock bidegree) grading of M(1)**, needed to separate
  `E^-_a(P)E^-_b(Q) iota(a+b)` blocks with different `Q` --- not landed.

**Status updates of record**: NOTES §107.1/§107.4's `CoherentCreatedStepShifted` row is now "PROVED from
`ShiftedCreationDerivation` (plus `hnd`, `hs`)"; ROADMAP batch-210 brief error (4) is sharpened --- the
`L(-1)` ladder is unusable only as a UNIVERSAL premise (`FockShiftZeroStep` is refuted), not pointwise.
**Accounting after batch 211**: the honest positive-pairing Fock residual is `ShiftedCreationDerivation`
(a known open identity whose generator case is landed); the negative-pairing content is reduced to
`HonestNegPairingZero`/`HonestNegPairingPos` on the built `pairBlock`, blocked on the M(1) bidegree grading;
(i) and (iii) untouched.

---

### Batch 212 — the Fock bidegree (and its h-weight refinement) is LANDED, and the Fock residual's residual is one `YFam`-mode derivation

**A — the currency bridge, and a machine-checked correction of batch 211's reading**
(`Definitions/MMFLM86ShiftedDerivationAux.lean` 189 lines, `MM.FLM86SDX` +
`Definitions/MMFLM86ShiftedDerivation.lean` 157, `MM.FLM86SDD`).

* `lMinusOne_eq_sugawaraModeZero` --- the formal currency bridge
  `lMinusOne hnd E = sugawaraModeZero hnd (-1)` (via `Yaligned_eq_Yzero_baseRepaired`), so batch 211-A's
  "reading across currencies" is now a THEOREM and `hnd` is legitimately spent (`L(-1)` is the conformal
  vector's mode).
* `ZAligned_iotaVL_eq_YFam` (`ZAligned E (iotaVL a) = YFam E a`),
  `sugawaraModeZero_neg_one_iotaVL`, `sugawaraModeZero_neg_one_anchorVL`.
* **`shiftedCreationDerivation_iff_YFamShiftedDerivation`** --- the residual is, BOTH WAYS, the tree spelling
  with the `YFam` modes; and `ShiftedCreationDerivation_of_modeDerivation`,
  `coherentCreatedStepShifted_of_modeDerivation`, `coherentCreatedStepPosNonneg_of_modeDerivation`: the two
  positive-pairing Fock faces follow from ONE named residual.
* **MACHINE-CHECKED CORRECTION (batch 211-A's reading was wrong)**: the residual's modes are the (8.4.17) field of
  the LATTICE generator (`YFam`), NOT the Heisenberg modes `modeVL` of the tree's
  `LMinusOneCreationMode`/`SugawaraDerivation`: at `a = 0`, `m = -1` they already differ on the vacuum
  (`YFam_zero_neg_one_vacuum` vs `ZAligned_iotaVL_zero_ne_modeVL_zero`).  Hence the residual is NOT the tree's
  state-half object --- which is a theorem unconditionally `MM.FLM87SR.sugawaraDerivation` (batch 165), so the
  stale "general-`w` case not landed" reading is corrected too.
* NOT proved: `YFamModeDerivation` (the tree spelling of the residual) and the generator base case
  `YFamDerivationBase`.  The creation-list STEP is hand-verified pure operator algebra on landed inputs
  (`modeVL_YFam_add` at `-k`/`-k-1`, `sugawaraDerivation`, `coefDeriv_apply`) and recorded verbatim in the
  docstring, but its Lean proof was WITHDRAWN (it failed at the final scalar-normalisation step; the
  `Module.End` smul API trap) --- with it plus `MM.FLM85Un.spanningStatement` the base case would give the
  target unconditionally modulo `hnd`/`hs`.
* **NOTE**: this agent did not add `#guard_msgs` guards (build budget); the dispatcher supplied an out-of-file
  `#print axioms` probe over all 16 public declarations --- all clean, no `sorryAx` (recorded here so the
  deviation is visible).

**B — the Fock bidegree and its h-weight refinement** (`Definitions/MMFLM86FockBidegreeAux.lean` 334 lines,
`MM.FLM86FBDA` + `...FockBidegree.lean` 356, `MM.FLM86FBD`; 29 public declarations, all guarded).

* **THE GRADING**: `bidegPiece N a` (the (Fock degree, lattice label) piece of `V_L = M(1) x F{L}`, the span of
  `vlMonomialBasis (d,a)` with `basisWt d = N`), with `bidegPiece_basis_mem`/`_mono_mem`/`_disjoint`/
  `_iSup_eq_top`, the bridge `bidegPiece_le_weightPiece` to the landed (coarser) `MM.FLMLattice.weightPiece`
  (NOT rebuilt), the projections `bidegProj` with their laws, and **THE SEPARATION LEMMA**
  `bideg_separation` (a finite sum of vectors of distinct bidegrees vanishes only if every summand does).
* the h-weight refinement: `hwWt d = sum_p d(p).p.1.h_p in h = H F L`, `hwWt_add`, `hwWt_single`,
  `hwPiece w a`, `hwPiece_basis_mem`, `hwPiece_disjoint`.
* MODE LAWS: `modeVL_neg_mem_bidegPiece` (`alpha_c(-n)`, `n >= 1`, raises the Fock degree by `n` and keeps the
  label; arbitrary `c` via the LANDED `MM.FLMFI.iota_single_mem_monoPiece`),
  `creationExpVL_mem_bidegPiece(_nat)` (homogeneity), and the block law
  `normOrdered2_iotaVL_mem_bidegPiece` (the (8.4.20) block at `iota(c)` is
  `E^-_a(M-<a,c>) E^-_b(K-<b,c>) iota(a+b+c)`, of degree `(M-<a,c>)+(K-<b,c>)` and label `a+b+c`).
* **FALSIFICATION (killed the brief's own reading)**: `pairBlock_block_deg` --- the two mode indices of EVERY
  `(q,k)`-summand of `MM.FLM86NOSA.pairBlock` add up to the constant `j + l - m - <a,b> - 1`, so at a lattice
  generator all summands have the SAME `(N,a)` bidegree and the SAME label: the coarse bidegree (and
  `weightPiece`) CANNOT separate the `E^-_a(P)E^-_b(Q) iota(a+b)` blocks with different `Q`.  The separating
  grading is the **h-weight refinement** `hwWt` (the `(q,k)`-summand carries `(M+1-Q)a + (Q-2)b`, different for
  different `Q` as soon as `a, b` are linearly independent).  This confirms batch 211-B's "threshold PER SHIFT
  INDEX" defect and gives its CAUSE as an identity.
* NAMED RESIDUAL: `FockAnnihilationDegreeLaw` (the exact-degree annihilation shift; the landed
  `MM.FLM84CM.modeVL_lowers` gives only the filtration bound `<= N - n`).  Next steps: the h-weight mode law and
  the h-weight block separation, then the two faces.
* GREP-FIRST record: `weightPiece`/`weightPiece_disjoint`/`isInternal`, `gradedPiece`, `monoPiece`,
  `basisWt`, `gradedPiece_mul_mem`, `span_inf_span_eq_bot_of_disjoint`, `fockDegreeOp`, `wtLabel` and
  `MM.FLMFI.iota_single_mem_monoPiece` all already existed and were CONSUMED, not rebuilt (one 25-line
  re-derivation was caught by the grep).  `fockLeVL` is a filtration, not a grading.

**Correction of record**: NOTES §108.4 / ROADMAP batch 211's "blocked on the M(1) bidegree grading" is superseded ---
the grading is landed, and the block bookkeeping needs its **h-weight refinement**, with the two faces still open
as `HonestNegPairingZero`/`HonestNegPairingPos`.

---

### Batch 213 — 🏆 THE POSITIVE-PAIRING FOCK FACES ARE PROVED (no named residual left), and the h-weight separation machinery is landed

**A — the residual closed** (`Definitions/MMFLM86YFamDerivationAux.lean` 319 lines + `...Base.lean` 266 +
`...YFamDerivation.lean` 403, namespace `MM.FLM86YFD`, 29 guards --- all public declarations guarded, no
`sorryAx`).

```
yFamResidualAt_modeVL (hnd) (hs) (E) {a b} {k} (hk : 1 <= k) {w} (h : YFamResidualAt a w) :
    YFamResidualAt a (modeVL b (-k) w)                       -- THE CREATION-LIST STEP
yFamResidualAt_stateOfVL (hnd) (hs) (E) (hbase) (a) (D) : YFamResidualAt a (stateOfVL D)
yFamModeDerivation_of_base (hnd) (hs) (E) (hbase : YFamDerivationBase hnd E) : YFamModeDerivation hnd E
yFamModeDerivation_iff_base (hnd) (hs) (E) : YFamModeDerivation hnd E <-> YFamDerivationBase hnd E   -- BOTH WAYS
yFamDerivationBase (hnd) (hs) (E) : YFamDerivationBase hnd E                -- THE BASE CASE
yFamModeDerivation / shiftedCreationDerivation (hnd) (hs) (E) : ...
coherentCreatedStepShifted (hnd) (hs) (E) : MM.FLM86CCN.CoherentCreatedStepShifted E
coherentCreatedStepPosNonneg (hnd) (hs) (E) : MM.FLM86CCPP.CoherentCreatedStepPosNonneg E
```

**So the positive-pairing Fock conjunct of the honest boundary package is a THEOREM modulo `hnd`/`hs` --- NO
named residual remains on that front.**  The base case needed the CREATION HALF of (8.10.13)/(8.10.14):
`[L(-1), E^-(a,z)] = (d/dz)E^-(a,z) - a(-1)E^-(a,z)`, proved ONCE abstractly over an arbitrary `Ring A` with
`Algebra Q A` (`sub_mul_of_deriv_expField`, file `...Base.lean`) --- a route that never opens the
`Module.End` scalar API, which is why batch 212-A's trap cannot arise.
**Traps of record.**  (i) The mode `-(k+1)` INDEX TRAP: the contraction at mode `-(k+1)` shifts the `YFam` index
by `k+1` (index `m-k-1`, NOT `m-k`); writing `m-k` leaves `-(m.<b,a>)` behind, because `module` sees
`YFam a (m-1-k)` and `YFam a (m-k-1)` as different atoms.  (ii) `MM.FLM86ZLI.modeVL_YFam_add` yields `-↑n` and
`j - ↑n`, only DEFINITIONALLY equal to `-1` / `m-1`, so `rw`'s keyed matching fails across the difference
(`simpa using h` fails where `exact h` succeeds) --- normalise the hypothesis first.  (iii) The brief's
`*_of_modeDerivation` signature has no `hs`; the "scalar-normalisation blocker" recorded by batch 212-A was an
artefact of the operator-level formulation (the step is pure VECTOR-level algebra); and the BASE case needs the
creation-exponential derivation property, which was not in the brief's input list.

**B — the h-weight separation** (`Definitions/MMFLM86HWeightSeparationAux.lean` 415 lines, `MM.FLM86HWA` +
`...HWeightSeparation.lean` 769, `MM.FLM86HW`; 52 guards).

* the generic basis-indexed projection machinery (`basisProj`, `basis_separation`, the telescoping law), its
  instantiation `hwProjM1`/`hwProj`/`hw_separation`/`hwProj_sum_eq_self_of_mem`, and the KEY
  `hwProj_eq_iff` (equality iff all h-weight components agree);
* the HONEST h-weight mode law: at basis labels `alpha_{b_i}(-n) : hwPiece w a -> hwPiece (w + n.h_{b_i}) a`
  (`modeVL_basis_neg_mem_hwPiece`, `creationExpVL_basis_mem_hwPiece`); for a GENERAL `c` the mode is NOT
  homogeneous --- only `iSup` membership holds (`modeVL_neg_mem_hwPiece_iSup`,
  `creation_ofLattice_mem_hwPieceM1_iSup`, via `ofLattice_eq_sum_hBasis` + `creation_eq_sum_ofLattice`) --- with
  the MACHINE-CHECKED REFUTATION `naiveHwModeLawRankTwo_false` (rank two, `c = b_0 + b_1`,
  `alpha_c(-1).1 = X_0 + X_1` lies in NO single `hwPiece`);
* the block laws at basis labels (`normOrdered2_basis_iotaVL_mem_hwPiece`) and the INDEX SEPARATION
  `pairBlock_block_weight_eq_iff` (for `i != j` the `(q,k)`-summand's h-weight determines `q+k` and conversely)
  + `pairBlock_blocks_distinct_hwPiece`;
* the two negative-pairing faces reduced, BOTH WAYS, to ONE named per-h-weight input each:
  `HonestNegPairingZeroHw` / `HonestNegPairingPosHw` (`honestNegPairingZero_iff_hw`,
  `honestNegPairingPos_iff_hw`; forward = project, backward = the telescoping law `hwProj_eq_iff`).
* **Corrections of record**: batch 212-B / NOTES §109.2's "the summand carries `(M+1-Q)a + (Q-2)b`, different for
  different `Q` as soon as `a, b` are linearly independent" is CORRECTED (the summand spreads over basis
  monomial weights and lies in no single `hwPiece` for general `a, b`; `pairBlock_block_deg` stands) --- the
  separation is honestly a BASIS-LABEL statement.  `hwWt` is a map on the EXPONENT VECTOR, not on `VL`;
  `hwPiece` takes the pair `(w, a)`.
* Still open there: the ASSEMBLED per-shift-index threshold, blocked on Mathlib's missing FIBERWISE-SUM lemma for
  `(q,k) |-> q+k` (only the `prod` version exists in this pin).  `FockAnnihilationDegreeLaw` was NOT needed.

**Milestone.**  At FLM's datum the honest package `EvenCocycleResidualsHonest` now has
`NegTwoFirstDerivZero` (batch 196), `NegThreeExpandedResidualAligned` (batch 204-A) and
`CoherentCreatedStepPosNonneg` (this batch) all as THEOREMS, so it reduces to the TWO NEGATIVE-PAIRING Fock
conjuncts alone (`CoherentCreatedStepNegPairingFactor`, `CreatedStepAtZeroNegPairingHonest`) --- which in turn are
reduced to `HonestNegPairingPos`/`HonestNegPairingZero` (batch 211-B) and then to the h-weight forms (batch
213-B).

---

### Batch 214 — the honest boundary REDUCED to the two negative-pairing Fock faces + the Jacobi step; the negative-pairing faces pinned to per-`Q` thresholds (one named input each)

**A — the assembly and the faces** (`Definitions/MMFLM86FiberwiseSum.lean` 295 lines, `MM.FLM86FWS` +
`...NegPairingFacesAux.lean` 317, `MM.FLM86NPFA` + `...NegPairingFaces.lean` 389, `MM.FLM86NPF`; 39 guards).

* **FALSE PREMISE CORRECTED**: Mathlib's fiberwise-sum lemmas ALL EXIST in this pin and are USED ---
  `Finset.sum_fiberwise`, `sum_fiberwise_of_maps_to`, `..._of_maps_to'`, `sum_fiberwise_eq_sum_filter`,
  `sum_biUnion`, `sum_sigma'`.  What was missing is the EXPLICIT fiber/image of the `pairBlock` window under
  `(q,k) |-> A-q-k`: `image_affine` (image `Icc (A+1-T) (A+T+1)`) and `fiber_affine` (fiber
  `Icc (max 0 (A-Q+1)) (min T (A-Q+T+1))` in `k`, `q = A-Q-k`), with the main lemma
  `sum_window_shiftIndex` proved BY `sum_fiberwise_of_maps_to`, plus the `(q,k) |-> q+k` form
  `sum_window_add`.  ROADMAP batch-213-B / NOTES §110.2's "blocked on Mathlib's missing fiberwise-sum lemma" is
  SUPERSEDED.
* **THE THRESHOLD ASSEMBLY IS LANDED**: `pairBlockShift` (one shift index `Q` with its OWN threshold `TQ`,
  block `normOrdered2 a b (C-Q) Q`) and `pairBlockIdx` (sum over `Q`), and
  `pairBlock_eq_pairBlockIdxMax : pairBlock ... T = pairBlockIdx ... (l-T) (l+T) (fun Q => T - max 0 (Q-l))`
  --- the landed single-`T` object IS the per-`Q` object with DIAGONAL thresholds
  (`diagThreshold_of_le`, `diagThreshold_coupled`).
* **THE FACES at the corrected object**: `HonestNegPairingZeroIdx`/`PosIdx` (arbitrary windows/thresholds),
  with `honestNegPairing*_iff_diag` (their diagonal slices are EXACTLY the batch-213-B faces, both ways) and
  `honestNegPairing*Idx_iff_hw` (both ways to the per-h-weight inputs).  `...Diag_imp_idx` shows the correction
  is a genuine WEAKENING (the landed single-`T` faces are stronger and false).
* **FALSIFICATION**: the landed single-`T` forms (`HonestNegPairingZero`/`ZeroHw`/`Pos`...) are FALSE on batch
  211-B's exact instance (`l = 1`, `m = -1`, `j = 0`, `<a,b> = -M`: the honest coefficients are `1` at `Q = 1`
  and `M` at `Q = 0`, but the diagonal family gives the SAME threshold `T` to both).  The coefficient core is
  machine-checked (`diagCoeff_pair_ne_one_one`: the diagonal coefficients `(T+1)(T+2)/2`, `T(T+1)/2` are never
  both `1`; `perQ_thresholds_attain_pair` attains `(1,1)`).  The OPERATOR-level refutation is NOT landed --- it
  needs LINEAR INDEPENDENCE of the distinct blocks `normOrdered2 a b (C-Q) Q`, i.e. the converse of
  `pairBlock_blocks_distinct_hwPiece` --- and is reported as the exact residual.
* So one named input per face remains (`HonestNegPairingZeroIdxHw`/`HonestNegPairingPosIdxHw`), plus that
  linear-independence lemma for the refutation.

**B — the REDUCED honest boundary** (`Definitions/MMFLM810BoundaryReduced.lean`, 521 lines, `MM.FLM810BR`,
5 defs + 12 theorems, 17 guards).

* **NO spelling mismatch**: `NegTwoFirstDerivZero` (hs only), `NegThreeExpandedResidualAligned` (hs, C, h2) and
  `CoherentCreatedStepPosNonneg` (hnd, hs) all apply at exactly `E = C.toCentralExtension h2`.
* `EvenCocycleResidualsHonestReduced C h2 := CoherentCreatedStepNegPairingFactor E /\
  CreatedStepAtZeroNegPairingHonest E`, with `evenCocycleResidualsHonest_iff_reduced` (BOTH ways) and
  **`theorem8102_of_negPairingFock (hnd) (hs) (C) (h2) (S) (hpd) (hW) (hfin) (hneg) (hzero) (hstep) : Theorem8102`**
  (+ the bundled `theorem8102_of_residualsHonestReduced`).
* Non-vacuity: `evenCocycleResidualsHonestReduced_of_forall_nonneg` and
  `evenCocycleResidualsHonestReduced_iff_of_forall_nonneg : Reduced <-> EvenCocycleResiduals`.
* Ledger of the step: `EvenCocycleJacobiStepReduced` + its iff, content named as
  **(i) `MM.FLM86C851.Corollary851ModeStep`, (iii) `MM.FLM86D866.Display866SecondEqK` at `k >= 3`**.
* Corrected-currency variants (batch-211-B's defect of record): `EvenCocycleResidualsHonestCorrected`,
  `EvenCocycleResidualsHonestReducedCorrected`, `EvenCocycleJacobiStepCorrected`,
  `theorem8102_of_honestNegPairingCorrected`.
* **HONEST LIMIT**: absolute satisfiability of the two negative-pairing conjuncts is NOT known; at `hpd` (positive
  definite) the `0 <= <a,b>` non-vacuity slice is UNAVAILABLE (`(x,-x)` is a negative pairing); and the two
  reduced packages (the 210-B spelling and the corrected one) are NOT shown equivalent.

**Note**: `AGENTS.md`'s "tools/build.sh is not usable on this machine" is STALE --- it has run every build in this
campaign fine.

---

### Batch 215 — the general OPE/insertion step is LANDED (all lengths), and the negative-pairing faces are pinned to their off-vacuum form (with the operator-level refutation of the old spelling)

**A — the negative-pairing faces** (Definitions/MMFLM86NegPairingFinalAux.lean 309 lines, MM.FLM86NPFX +
...Final.lean 274 + ...FinalRefute.lean 369, MM.FLM86NPF2; 31 guards).

* **The vacuum slice is a THEOREM**: honestNegPairingZeroIdx_vacuum / PosIdx_vacuum (+ their Hw forms) --- at
  w = vacuumVL and m >= 0 the honest left-hand side is 0 (FLM (8.10.7) first half, MM.FLM810TA2.creationRegularAligned)
  and the right-hand side is 0 by the EMPTY window.
* Each face is reduced, BOTH WAYS, to one strictly smaller named input: HonestNegPairingZeroIdxHwNonvac /
  HonestNegPairingPosIdxHwNonvac (the vacuum case excluded), via honestNegPairing*IdxHw_iff_nonvac.
* **The block independence** (part 2): hw_separation_of_injOn, blockShift/blockShiftWeight, blockShift_mem_hwPiece,
  blockShiftWeight_injOn, and the CONVERSE of pairBlock_blocks_distinct_hwPiece: **normOrdered2_blocks_no_cancel**
  (distinct-Q blocks cannot cancel), normOrdered2_blocks_coeff_unique, normOrdered2_blocks_combination_ne.
  Limits: needs linearly independent labels (i != j); single-block nonvanishing is an explicit hypothesis.
* **OPERATOR-LEVEL REFUTATION of the single-T ancestors** (batch 214-A could only refute their coefficients):
  not_honestNegPairingZero_rankOne (+ Diag/Hw and the three Pos twins) at the rank-one datum (L = ZZ,
  <m,n> = -mn, a = b = 1, l = 0, m = j, w = vacuumVL, so C = 0): rankOne_pairBlock_vacuum_eq gives
  pairBlock = (sum_{k<=T} binomCoeff (-k-1) j) . anchorVL with scalar T+1 > 0 (j = 0) resp. -(T+1)(T+2)/2 < 0
  (j = 1) --- nonzero for EVERY T, while the honest left side is 0.
* **Corrections**: (i) the operator-level refutation did NOT need the block independence (at C = 0 only the Q = 0
  block survives) --- ROADMAP batch 214 / NOTES 111.2's account is superseded; the independence lemma is landed
  anyway as the tool for the off-vacuum residual.  (ii) The corrected per-Q faces are NOT refuted and the
  correction is not vacuous.  (iii) Two attempted further reductions are recorded as NON-reductions (basis-state
  restriction; single-shift collapse).

**B — the general insertion step** (Definitions/MMFLM86Display866ThreeAux.lean 506 lines, MM.FLM86D866T +
...Insert.lean 219 + ...Three.lean 248; 32 guards).

* **powerFam_nestedExp --- THE GENERAL OPE/INSERTION STEP, a THEOREM for every length**:
  powerFam a p (E^-_{b_1}(x_1)...E^-_{b_l}(x_l) iota(c)) = sum_{k in box} (prod_j ratioCoeff <a,b_j> k_j) .
  E^-_a(p - <a,c> + sum_j k_j)(... iota(ac)), with only hs and 0 <= <a,b_j>.  At l = 1 this is the landed k = 2
  slice (MM.FLM86YP.YFam_mul_apply_eq_sum_ratioCoeff), at l = 0 the landed (8.5.11) shift.  This is exactly what
  the batch-208-B ledger called the general OPE/insertion step (the k >= 3 case of (8.4.22)/(8.4.36)); residual
  (i) of MMFLM86YFamProduct's header is closed and Contraction8612Ratio is NOT on the path.
* Supporting: the l-fold (8.4.19) contraction (annihExp_nestedExp), the general-label commutations, the MidLabel
  sector and its preservation, the nestedExp carrier of (8.6.5) and its laws (nestedExp_eq_or,
  series865_eq_nestedExp), piFinset_succ/sum_piFinset_succ.
* The series spelling Display866SeriesK with the BOTH-WAY equivalence display866SecondEqK_iff_seriesK, the
  composition display866Display_of_series (giving (8.6.6) for the new range) and the k <= 2 slices.
* **ONE NAMED RESIDUAL: Display866SeriesStep k** --- the k -> k+1 ASSEMBLY, i.e. the finite regrouping
  PairIdx (k+1) = PairIdx k + Fin k with the induced splittings of pairWeightK/pairShiftK/blockScalarK.  Its OPE
  half is PROVED; only the finite-index bookkeeping remains.  Reductions: display866SeriesStep_iff (step <-> the
  (k+1)-st case given the k-th) and display866SecondEqK_three_of_step : Display866SeriesStep 2 ->
  Display866SecondEqK 3.
* FALSIFICATION CHECK: a Python rank-one lattice model, positive pairings at k = 3 ((1,1,1),(1,2,3),(1,1,2),
  (2,3,1)) and k = 4 ((1,1,1,1)): 189/189 index tuples agree, 0 mismatches; a negative pairing (2,-1,1)
  mismatches, confirming 0 <= <abar_i,abar_j> is load-bearing.

**Ledger deltas**: NOTES 105.2/111.4 and ROADMAP batch 214 item (iii) are STALE in their diagnosis --- the
general insertion step is landed; (iii) now reduces to Display866SeriesStep (with k = 3 from the landed k = 2
slice + the k = 2 step).  NOTES 111.4's block-independence row is LANDED, and the per-face input is refined to
the OFF-VACUUM residuals.

---

### Batch 216 — 🎉 item (iii) IS CLOSED (Display866SeriesStep is a theorem for every k), and item (i) is REFUTED as spelled (the window is a TRUNCATION, not a parameter) and replaced by the window-free form

**A — (iii) closed** (Definitions/MMFLM86Display866SeriesStepAux.lean 656 lines + ...SeriesStep.lean 671, 70 guards).

* **display866SeriesStep : Display866SeriesStep bL form E k --- a THEOREM for every k**, hence
  **display866SecondEqK_all : Display866SecondEqK at every k >= 1** (with the unconditional
  display866SecondEqK_three, display866SeriesStep_two, display866SeriesK_three).  The previously conditional
  display866SecondEqK_three_of_step is superseded.
* Machinery: the finite-index decomposition PairIdx (k+1) = PairIdx k + Fin k (newPairIdx/tailPairIdx with an
  exhaustive case analysis), the assembly map pairFunJoin (eta/injective/mem), the reindexing of pairShiftK's four
  filtered sums, pairWeightK_join, pairShiftK_join_zero/_succ, pairSetK_succ/sum_pairSetK_succ, nestedExp_smul;
  step_left (induction hypothesis + the landed powerFam_nestedExp), step_left_filter (a negative creation index
  kills the terms, creationExpVL_eq_zero_of_neg), step_right (the filter decomposition of the target), and the term
  identification (the (7.1.28) cocycle landing on anchorVL).  Two kernel small-instance cross-checks against the
  landed k = 2 slices.
* **SO JACOBI LEDGER ITEM (iii) IS CLOSED**: Display866SecondEqK holds at every k >= 1.  NOTES 112.1/112.4 and
  ROADMAP batch 215-B's 'ONE NAMED RESIDUAL' line are STALE.
* Brief errors: piFinset_succ/sum_piFinset_succ are NOT the assembly's regrouping tools (they regroup over a
  VARIABLE index Fin (l+1); the assembly needs the PAIR index PairIdx (k+1), which did not exist and is landed
  here); and def-defined filter predicates (or a local Classical.propDecidable) break statement-level
  DecidablePred/defeq matching against the imported Display866SeriesK --- abbrev predicates are the fix.

**B — item (i) refuted as spelled; corrected ledger landed** (Definitions/MMFLM86Corollary851ModeStepProveAux.lean
227 lines + ...Prove.lean 463, 21 guards).

* **THE REFUTATION** (only hs, arbitrary E): not_corollary851ModeStep_zero and not_corollary851ModeStep_one ---
  the same-window Corollary851ModeStep is FALSE at K = 0 and K = 1.  Mechanism: corollary851_vacuum_left shows the
  hypothesis C vacuumVL w K is FREE at every K ((8.5.3) Y(1,z)=1 makes the iterate supported at i = -1, outside the
  window), while the conclusion C v v K fails for v = oneFactorState a (c = a, r = 1): the (1,-1) commutator is the
  (7.1.5) central term <a,a>.1 != 0, the K = 0 residue is the EMPTY sum and the K = 1 residue is (Y v)_0 v = 0 (the
  k = 0 component is the (7.1.33) zero mode, which kills the Fock-descended vacuum: zAligned_oneFactor_zero,
  oneFactor_zero_apply, commutator_oneFactor).
* **KEY STRUCTURAL FACT**: the window of Corollary851 is a TRUNCATION, not a parameter ---
  iterateOf_eq_zero_of_corollary851_succ shows any C u v K -> C w v K forces the K-th iterate of (w,v) to vanish
  (the coefficient is deltaExpCoeff K K = (-1)^K, a unit in char 0).  Hence the same-window step is STRICTLY
  STRONGER than FLM (8.5.13), and a consumer whose hwin forces K = 1 (some pairing -1, none <= -2) uses an
  UNSATISFIABLE hypothesis.
* **CORRECTED LEDGER LANDED**: Corollary851ModeStepExists (WINDOW-FREE: C u v K -> exists K', C (mode u) v K'),
  Corollary851ModeStepExistsAt (hypothesis window pinned), corollary851ModeStep_imp_existsAt,
  corollary851ModeStepExists_iff_forall_existsAt (BOTH ways), the window-threaded (8.5.4) induction
  corollary851_spanningStates_exists_of_lattice_and_step, and corollary851_spanningStates_exists_of_residual_and_step
  (the corner supplied by the landed batch-204-A theorem).  **So (i) has exactly ONE named input:
  Corollary851ModeStepExists (ZAligned E).**
* Content of that residual: (1) the mode--field commutators [alpha_c(e), ZAligned E v n] at ARBITRARY v --- in
  particular the ANNIHILATION modes alpha_b(n), n >= 0, are evaluated NOWHERE in the tree (the landed (7.1.5)
  lemmas are generator-field and creation-mode only); (2) the (8.6.25)/(8.6.27) residue matching, where batch 215's
  powerFam_nestedExp is already a piece.  Batch 213-A's YFamModeDerivation/zLineModeAt_all do NOT close this, and
  the batch-204-B dead end is confirmed.
* Ledger corrections: NOTES 100.3/111.1/111.4/112.1 and ROADMAP batches 203/205 name the SAME-WINDOW spelling as
  residual (i) --- that must become the window-free (or explicitly windowed) form; and ROADMAP 205-B/NOTES 102.3's
  identification of the missing input with the mode--field commutators ALONE misses the independent window defect.

**Accounting after batch 216**: the campaign needs ONLY (i) Corollary851ModeStepExists (the two pieces above),
the two off-vacuum negative-pairing Fock faces (HonestNegPairingZeroIdxHwNonvac / HonestNegPairingPosIdxHwNonvac),
and the six boundary inputs hnd/hs/S/hpd/hW/hfin.

---

### Batch 217 — item (i) reduced to THREE named residuals; the two negative-pairing faces reduced (both ways) to their BLOCK form

**A — item (i)** (Definitions/MMFLM86Corollary851ModeStepExistsAux.lean 375 lines + ...Exists.lean 321,
MM.FLM86C851P).

* BOTH-WAY reduction to one named input per half: Corollary851ModeStepExists Y <-> ModeStepLeftExists Y /\
  ModeStepRightExists Y, and each half <-> the package of its fixed-window slices
  (corollary851ModeStepLeft/RightExists_iff_forall_existsAt).
* the all-states reading named (Corollary851AllStatesExists := forall u v, exists K, C u v K),
  corollary851ModeStepExists_of_allStates, and corollary851ModeStepExists_iff_allStates (BOTH ways, modulo the
  named lift Corollary851SpanningToAllStates and the landed batch-204-A corner).
* NEW mode--field theorems: the uniform (7.1.5) base-field law for every nonzero mode index (modeVL_YFam_add_ne,
  merging the landed creation and annihilation halves), modeVL_iotaVL_eq_zero_of_pos, and **ModeFieldCommInput**
  (the (8.6.10) commutator [alpha_c(e), Y(v)_n] = sum_j binom(e,j) Y(alpha_c(j)v)_{n+e-j} at ARBITRARY v) PROVED
  at the lattice generators (FLM (8.6.38)) AND on their span (modeFieldCommAt_of_mem_span) --- so its open content
  is exactly the OFF-GENERATOR (8.5.4) states.
* THREE NAMED RESIDUALS: (1) ModeFieldCommInput off the generator span ((8.6.9)/(8.6.10) for oscillator states);
  (2) ResidueInsertion8625 (the (8.6.25)/(8.6.27) field insertion/residue matching); (3)
  Corollary851SpanningToAllStates --- NOT bookkeeping: of_cutoff can raise a window only when the iterate vanishes
  from it on, and the landed (8.10.5) truncation is VECTORWISE (ComponentTruncation per pair), the state-level
  vanishing being landed only at lattice pairs (stateVanishesBelow_ZAligned).
* CORRECTIONS (measured): the claim "the ANNIHILATION modes alpha_b(n), n >= 0, are evaluated NOWHERE in the tree"
  (ROADMAP 216-B / NOTES 113.3) is STALE --- batch 192-A landed them at the honest assembled field
  (MM.FLM86TC2.modeVL_YFam_add_pos, MM.FLM86TC2.hZeroVL_YFam_add, MM.FLM86TC2.convWith_modeVL_add_left, plus
  MM.FLM84CT.modeVL_comm_creationExpVL, MM.FLM86TN.modeVL_comm_annihExp_pos, MM.FLM86TC2.hZeroVL_comm_annihExp);
  what is open is only the arbitrary-STATE commutator.  Name corrections: Corollary851ModeStepExists is
  MM.FLM86C851P (not MM.FLM86C851); all-states is MM.FLM86C851.*; the residue is MM.FLM85Co.corollary851Residue and
  the delta coefficients MM.FLM85Br.deltaExpCoeff.

**B — the two negative-pairing faces in block form** (Definitions/MMFLM86NegPairingNonvacAux.lean 350 lines,
MM.FLM86NPNA + ...NonvacAnchor.lean 193 + ...Nonvac.lean 378, MM.FLM86NPN).

* pairBlockIdx_eq_blockCombination: pairBlockIdx over [lo,hi] IS a finite block combination over Icc lo hi;
  dropping the window gives the named inputs HonestNegPairing*IdxHwNonvacBlock --- off the proved vacuum slice,
  a FINITE set s of shift indices with ONE truncation integer per index, the coefficient of Q being a partial sum
  over the FORCED window [max 0 (l-Q), Tfun Q] --- with BOTH-WAY reductions
  honestNegPairing*IdxHwNonvac_iff_block (backward by [min' s, max' s] + blockCoeff_eq_zero_of_lt inside
  Finset.sum_subset).
* lhsIdx_anchor_apply_of_neg: at l = 0 the faces' LHS IS eps(a,b).coherentFieldNat at the anchor iota(a+b) of
  degree j - <a,b>, at EVERY pairing (no positivity!); the two anchor inputs are equivalent to the l = 0 slices
  (...Block_anchor_iff).  Plus pairBlockIdx_iotaVL + blockOfShift_iotaVL_eq_zero_of_lt_left/_right (the RHS at a
  lattice generator with its support window Icc (<b,c>) (C - <a,c>)) and creationExpVL_eq_YFam_vacuum
  (E^-_b(z_0)_l iota(b) IS the honest mode YFam E b (-(l)-1) on the vacuum).
* FALSIFICATION RECORD (Probe/b217b_falsification.py, a NECESSARY condition only): at the rank-one negative datum
  the honest vector lies in the block span with reachable nonneg-integer partial-sum coefficients (pattern: c = C
  on each pair {Q, C-Q}, C/2 at the middle) for C = 1..12; the single-T diagonal family fails already at C = 2
  (batch 214-A/215-A's diagCoeff_pair_ne_one_one in this currency).
* TRAPS OF RECORD: (1) a first-draft "refutation" was an ARITHMETIC ERROR (E^-_2(r) is NOT 2^r h_r --- the
  doubling gives (E^-_1)^2); (2) hwProj/hwProj_eq_iff live in MM.FLM86HWA, normOrdered2_vacuum in MM.FLM86MI;
  (3) MM.FLM86D866T.powerFam_nestedExp needs 'import Definitions.MMFLM86Display866Insert'; (4) rw with an instance
  at j := 0 produces the key -(up-arrow 0)-1 which does NOT match -1 (state a have first --- batch 213's
  zero-coercion trap); (5) by_cases on a goal not P -> Q leaves not P in both branches; (6) a '/-! ##' header
  missing its '-/' reports 'unterminated comment' at EOF.
* DISPATCHER NOTE: the fresh-build verification initially FAILED on B's three files (the guards referenced names
  from the agent's own late write); after the final write all three build clean (3x OK, 0 error, 0 sorryAx).
  Re-verify an agent's files AFTER its last write, always by deleting the oleans.

**Accounting after batch 217**: the campaign needs (i)'s three residuals (ModeFieldCommInput off-generator,
ResidueInsertion8625, Corollary851SpanningToAllStates), the Fock four named block/anchor inputs (equivalent to the
two faces), and the six boundary inputs.

---

### Batch 218 — (i) reduced to ONE named annihilation input (its zero half closed); and the Fock negative-pairing j=0 face is REFUTED in every spelling (block / per-Q / Idx), with the FREE-coefficient form as the corrected residual

**A — (i) to one input** (Definitions/MMFLM86ModeFieldCommAux.lean 202 + ...Zero.lean 403 + ...ModeFieldComm.lean 140 +
...Ann.lean 477).

* modeFieldCommInput_iff_step (BOTH WAYS); modeFieldCommStep_zero_clause + **modeFieldCommZeroHalf: the ZERO-MODE
  half of (8.6.9)/(8.6.10) at EVERY state is a THEOREM**;
* modeFieldCommInput_iff_annHalf / _iff_annStep (BOTH WAYS): the off-generator content of the input is EXACTLY ONE
  named statement --- **MM.FLM86MFC.ModeFieldCommAnnStep E**, the one-oscillator ANNIHILATION clause;
* machinery landed and reusable: modeVL_mul_splitMinus_factorFamilyZero (the (7.1.5) scalar defect e.<c,b> firing
  only at i = e-k with coefficient C(i+k-1,k-1)), the ^+ half contributing NOTHING (modeVL_mul_splitPlus_*),
  modeVL_headWindow_ann / modeVL_tailWindow_ann through both (8.4.16) halves, and sum_scalar_term (the summed defect
  = C(e,K).K.<c,b> at the shifted index --- exactly the extra RHS term from [alpha_c(K), alpha_b(-K)] = K.<c,b>).
* Brief errors: the MM.FLM86YFD derivation identity is the Sugawara L(-1) one (NOT the (7.1.5) mode-field
  commutator); powerFam_nestedExp routes to ResidueInsertion8625, not to this target; the circularity warning about
  actionFamily_*_modeVL was CORRECT and honoured; MM.FLM86TC2's annihilation laws are at GENERATORS only; the
  correct name is MM.FLM86C851E.ModeFieldCommInput.  Traps: rw does NOT rewrite under a Finset.sum binder with a
  forall-lemma (use Finset.sum_congr + show/ring); section variables bL/form become the FIRST explicit args;
  LinearMap.one_apply does not exist (Module.End.one_apply); smul_mul does not exist (mul_smul_comm/smul_mul_assoc);
  Int.cast vs Nat.cast need Int.cast_natCast.

**B — the Fock negative-pairing j = 0 face REFUTED** (Definitions/MMFLM86NegPairingBlockProveAux.lean 295 +
...Aux2.lean 182 + ...Prove.lean 312, MM.FLM86NPBP).

* THE COUNTEREXAMPLE (rank-one, L = ZZ, <m,n> = -mn, a = b = 1, trivial cocycle, (l,j,m,w) = (0,0,1,iota(1)) ---
  OFF the vacuum slice, rankOne_iotaVL_one_ne_vacuum by bidegree separation):
    rankOne_lhs : ZAligned E (YFam E 1 (-1) (creationExpVL 1 0 (iotaVL 1))) 1 (iotaVL 1)
                    = -(eps(1,1)*eps(2,1)) . rankOneVec
    rankOne_rhs (s) (Tfun) : exists K, 0 <= K and (blockCombination ...) (iotaVL 1)
                    = (K*(eps(1,1)*eps(2,1))) . rankOneVec
  so the identity forces -1 = K >= 0.  The evaluation uses (8.10.13) L(-1)iota(a) = alpha_a(-1)iota(a) at a = 2,
  the translation law Y(L(-1)v,z) = (d/dz)Y(v,z), and (8.5.11); at iota(1) the blocks vanish except Q = 0 and
  Q = -1 (which COINCIDE), and blockCoeff at j = l = 0 is a window CARDINALITY.
* REFUTED (machine-checked): not_honestNegPairingZeroIdxHwNonvacBlock_rankOne (217-B's block form),
  not_honestNegPairingZeroIdxHwNonvac_rankOne (215-A), not_FLM86NPF_HonestNegPairingZeroIdxHw_rankOne (214-A).  The
  j >= 1 (Pos) face is NOT refuted by this method.
* WHY 217-B's CHECK MISSED IT: its script tested w = vacuumVL with C = -m = 1..12 (m <= -1), where the honest
  coefficient -m/2 is POSITIVE and every block at m > 0 vanishes; at w = iota(c) with m > 0 the honest ordered-pair
  coefficient is -m/2 < 0 while blockCoeff is a cardinality.  Re-run: Probe/b218b_falsification.py.
* CORRECTED FORM LANDED: MM.FLM86NPBP.HonestNegPairingZeroIdxHwNonvacBlockFree --- the same statement with an
  ARBITRARY finite coefficient family coef : ZZ -> F in place of blockCoeff ... (Tfun Q); implied by both the
  (refuted) block form and the 215-A residual, and NOT refuted (rankOne_free_attained with s = {0},
  coef = fun _ => -1).  It is the new named residual.  The defect is exactly the FORCED partial-sum coefficient.
* **Consequence**: MMFLM810BH's negative-pairing j = 0 conjunct (CreatedStepAtZeroNegPairingHonest and relatives)
  may be UNSATISFIABLE, so that boundary hypothesis is likely vacuous too; the honest statement must be re-derived
  from FLM (8.6.25)/(8.6.27) directly.  FLM's own displays are NOT in question --- our reading of their right-hand
  side is.
* Ledger corrections: ROADMAP batch 217 / NOTES 114.2/114.4's "four named block/anchor inputs" are FALSE (replace
  by the free form); 215-A's "the per-Q faces are NOT refuted" and 217-B's "the check does NOT refute" are
  superseded (both tested only w = vacuumVL, m <= -1); NOTES 114.1's "off the generator span" is now exactly
  ModeFieldCommAnnStep (both ways), with the zero half a theorem.

**Accounting after batch 218**: the campaign needs (i) = ModeFieldCommAnnStep + ResidueInsertion8625 +
Corollary851SpanningToAllStates; the Fock side = the free form (or a re-derived honest statement); and the six
boundary inputs.

---

### Batch 219 — 🎯 ModeFieldCommInput IS PROVED (all states); the honest (8.6.25)/(8.6.27) coefficient is a BINOMIAL; and the honest Fock boundary package is REFUTED (the boundary hypothesis is VACUOUS)

**A — the honest coefficient** (Definitions/MMFLM86NegPairingHonestAux.lean 321 + ...Aux2.lean 250 +
...Honest.lean 500).

* **THE ANSWER**: reading FLM (8.6.25)/(8.6.27) (printed p. 210; Remarks 8.5.2 p. 200, 8.6.4 p. 211) at
  A = iota(a), B = iota(b) by extracting [w^0 x^0] (which returns the landed (8.5.11) value) and then [z_0^N] of
  the normal-ordered product gives
    ZAligned E (YFam E a (-1) iota(b)) m w = sum_Q binomCoeff (C-Q) N . :Y(a,b):(C-Q, Q) w,
    C = blockFirstIdx 0 0 m <a,b> = -m - <a,b> - 1,   N = -<a,b> > 0,
  the coefficient attached to the FIRST (a-)index P = C-Q.  This is NOT the (8.5.37) fiber sum / blockCoeff (a
  cardinality) and NOT the pairBlock partial ratioCoeff sum.  At N = 1 the coefficient is the integer C-Q;
  collecting the equal ordered pairs (creationExpVL_comm) gives the symmetric average C/2 = -m/2 --- exactly
  batch 218-B's measurement and 217-B's vacuum pattern.  Machine-checked for EVERY mode m and w = iota(c)
  (rankOne_lhs_all_modes, rankOne_coeff_determined_range, rankOne_coeff_determined).
* **NEW REFUTATIONS** (machine-checked at (a,b,l,m,w) = (1,1,0,1,iota(1))): rankOne_ne_pairBlock;
  not_honestNegPairingZero_rankOne (batch 211-B's "corrected slot"); not_honestNegPairingZeroAtZero_rankOne;
  **not_createdStepAtZeroNegPairingHonest_rankOne** (batch 210-B's def PROVED FALSE, not merely "possibly
  unsatisfiable"); not_createdStepAtZeroNegPairingHonestCorrected_rankOne; not_fockResidualHonest_rankOne;
  not_fockResidualHonestCorrected_rankOne; and **not_evenCocycleResidualsHonest_of_toCentralExtension** --- so
  theorem8102_of_residuals_honest (batch 210-B) and theorem8102_of_negPairingFock (batch 214-B) are VACUOUS, and
  the Fock ledger must be re-stated on the corrected coefficient.
* **CORRECTED RESIDUAL**: HonestNegPairingZeroCoeff E --- free support s, DETERMINED coefficient
  honestBlockCoeff = binomCoeff (C-Q) N; attained at the falsifying datum (rankOne_coeffDet_attained), implying the
  batch-218 free form on the l = 0 slice.  Corrected package
  FockResidualHonestCoeff = CoherentCreatedStepPosNonneg /\ HonestNegPairingPos /\ HonestNegPairingZeroCoeff.
  Slices 1 and 2 SURVIVE (slice 2 is under suspicion: its spelling uses the same pairBlock/cardinality object).
* Not proved: HonestNegPairingZeroCoeff at general (a,b,w); the general-N coefficient (derived in the Aux header,
  only N = 1 machine-checked --- general N needs the open (8.6.27) dictionary); the l >= 1 slices; the j >= 1 face.
* Brief errors: MM.FLM86NTP.residueNegativeAligned_evenCocycle does NOT resolve (the landed proved residue is
  MM.FLM86NTP.negThreeExpandedResidualAligned_evenCocycle); batch 210-B's object pins the second (8.5.37) slot at 0
  while pairBlock pins it at l (so the implication holds only at l = 0); API traps: LinearMap.sum_apply before
  Module.End.mul_apply, sub_smul needs explicit args, Int.toNat(-1) = 0.

**B — ModeFieldCommInput PROVED** (Definitions/MMFLM86ModeFieldCommAnnProveAux.lean 187 + ...AnnProve.lean 323).

* **modeFieldCommAnnStep is a THEOREM**, hence modeFieldCommAnnInput and **modeFieldCommInput** --- the full
  (8.6.9)/(8.6.10) mode--field commutator at ARBITRARY states, spending only hs.  Item (i)'s first residual is
  CLOSED.  Landed bridges: YtjFam, Yzero_modeVL_fam, Yzero_modeVL_window, hZeroVL_modeVL_comm_apply,
  sum_state_term.
* BRIEF ERROR (mine): the criterion "thence to Corollary851ModeStepExists" is FALSE --- no landed theorem reduces
  ModeFieldCommInput to it and nothing consumes ModeFieldCommInput as a hypothesis; the three (i) residuals are
  PARALLEL, and the bridge is the (8.6.4)--(8.6.27) residue matching (= ResidueInsertion8625).
* Technical: the tail window must be max (X.bound x) (X.bound (modeVL c e x)); the head window a FINITE SUM of
  descendant bounds, not a single X.bound x; orientation headOp_eq_headWindow / tailOp_eq_tailWindow.

**Accounting after batch 219**: Fock = HonestNegPairingZeroCoeff (j = 0) + HonestNegPairingPos (j >= 1, under
suspicion) + the general-N coefficient; (i) = ResidueInsertion8625 + Corollary851SpanningToAllStates (+ the
mode-field-to-mode-step bridge); the six boundary inputs.  EvenCocycleResidualsHonest / FockResidualHonest /
FockResidualHonestCorrected are REFUTED and must not be consumed; the honest boundary has to be re-stated on
FockResidualHonestCoeff.

---

### Batch 220 — slice 2 (j >= 1) is REFUTED too; the honest residual is HonestNegPairingCoeff, whose proof reduces to ONE vertex-algebra-free reindexing; ResidueInsertion8625 is only the finiteness half

**A — slice 2 refuted** (Definitions/MMFLM86NegPairingCoeffGeneralAux.lean 414 lines + ...CoeffGeneral.lean 225).

* **not_honestNegPairingPos_rankOne**: HonestNegPairingPos is FALSE at the rank-one datum
  (a,b,j,l,m,w) = (1,1,1,0,3,iota(1)) --- NON-VACUUM, NON-GENERATOR.  The honest LHS is iotaVL 3 (via the landed
  zAlignedGeneratorFlat + the ZAligned_JZF_eq bridge; no new input), while pairBlock ... 1 0 3 T (iotaVL 1)
  = K_T . iotaVL 3 with K_T = -(sum_{k in Icc 1 T} (k+2)) <= 0 for EVERY threshold T (only the shift index
  Q = -1 survives), so 1 = K_T contradicts (smul_eq_zero + iotaVL_ne_zero).
* => FockResidualHonestCoeff (batch 219-A's corrected package) is REFUTED on its second conjunct; the ledger must
  use HonestNegPairingCoeff.
* The corrected coefficient GENERALISED: honestBlockCoeffJ a b j m Q = binomCoeff (blockFirstIdx j 0 m <a,b> - Q)
  (j + (-<a,b>).toNat), with honestBlockCoeffJ_zero (at j = 0 it IS batch 219-A's binomial, rfl-level), the
  corrected face HonestNegPairingCoeff (free support + DETERMINED binomial) with its j = 0 / j >= 1 slices, and
  rankOne_coeffJ_attained (attained at the falsifying datum: single block Q = -1 with binomCoeff(-1,2) = 1).
* The general-N/general-j coefficient is DERIVED (through the landed zAlignedGeneratorFlat: expand flatMul,
  reindex p = i+n-l, apply the landed Chu-Vandermonde MM.FLM86ZM.binomCoeff_add_eq_sum) and numerically verified,
  and its formal proof reduces to ONE NAMED VERTEX-ALGEBRA-FREE identity --- **FlatBinomialExpansion**: for a
  commutative Q-algebra A, X Y : Z -> A, s : Z, n : N, TOT : Z,
    sum_{l in range (n+1)} binomCoeff s l . ((n-l)! : Q)^-1 . flatMul (iterDeriv (n-l) X) Y (l + TOT - n)
      = sum_{p in range (TOT.toNat+1)} binomCoeff (p + s) n . (X p * Y (TOT - p)),
  whose only gap is the (l,i) |-> p double-sum reindexing in Finset.sum_range.  Numerically verified at N = 1
  (j = 0..3, c = 1..3, m = 1..6, all blocks, 0 mismatches).  HonestNegPairingCoeff at general (a,b,w), the
  off-generator support and the l >= 1 second slot remain open.
* Brief errors: target (1) as spelled was a definitional triviality (honestBlockCoeff IS that binomial by def) ---
  the content is the FIELD identity; powerFam_nestedExp needs 0 <= <a,b_j> (positive pairing) and is NOT the
  route (zAlignedGeneratorFlat + binomCoeff_add_eq_sum suffice at generators); the "same cardinality object"
  diagnosis is inaccurate at j >= 1 (there the pairBlock coefficient is a genuine binomial PRODUCT, yet the face
  is still false --- wrong index attribution / coupled window); the batch-211-B checked instance does not extend
  to m > 0.

**B — the finiteness half proved; the matching is open** (Definitions/MMFLM86ResidueInsertion.lean 217 +
...SpanningLift.lean 326).

* **ResidueInsertion8625 IS PROVED --- but it is only the FINITENESS side** (its own docstring says so):
  iterateOf (ZAligned E) (alpha_c(-r)u) v k = 0 for k >= N, a corollary of (8.10.5) at the honest field
  (componentTruncationAligned kills the whole j-family: exists_iterateOf_eq_zero_of_truncation,
  residueInsertion8625), with non-vacuity machine-checked (iterateOf_zAligned_lattice_ne_zero: the iterate is
  NONZERO at the (8.5.11) boundary index -<a,b>-1).  => **the (8.6.25)/(8.6.27) MATCHING (the normal-ordered
  insertion Y(Y(A,z_0)B,z_2) = 8Y(A,z_2+z_0)Y(B,z_2)8 . prod (z_0+w_i-x_j)^{<a_i,b_j>}) is UNNAMED and OPEN**, and
  proving the finiteness half does NOT advance item (i).  Also: batch 217-A/219's "obstruction (b)" is WRONG ---
  vectorwise (8.10.5) DOES give state-level thresholds at arbitrary pairs; the real obstruction is WINDOW
  SYNCHRONIZATION (their (a)).
* **Corollary851SpanningToAllStates <-> Corollary851SpanningEventualWindows Y** (per-pair eventual windows; both
  spellings equivalent, spanningGrounded_iff_eventual), with the reduction corollary851Lift_of_eventual PROVED for
  arbitrary Y (finite expansion exists_stateFinset_mem_span + a common window exists_corollary851_of_mem_stateSpan
  + MM.FLM85Fock.corollary851_of_mem_span); the input is NOT implied by the landed hypothesis and the gap is
  machine-checked (not_corollary851_succ_of_first_ne_zero); the lift itself is neither proved nor refuted.
  Falsification: two scalar pairs with windows [3,4,5] and [0] --- each has a window, none common.

**Accounting after batch 220**: Fock = HonestNegPairingCoeff (both slices) <-- FlatBinomialExpansion;
(i) = the unnamed (8.6.25)/(8.6.27) matching + Corollary851SpanningEventualWindows (+ the mode-field input is
PROVED); the six boundary inputs.

---

### Batch 221 — 🎯 FlatBinomialExpansion PROVED (with an honest correction), HonestNegPairingCoeff at l = 0 PROVED AT THE LATTICE GENERATORS, and the (8.6.25)/(8.6.27) matching NAMED with half of it a THEOREM plus the mode-step bridge PROVED

**A — the flat identity and its instantiation** (Definitions/MMFLM86FlatBinomial.lean 554 lines +
...FlatBinomialApply.lean 285; 25 guards).

* **HONEST CORRECTION (machine-checked)**: the batch-220 spelling sum_{p in Finset.range (TOT.toNat+1)} is FALSE at
  TOT < 0 (rangeSpelling_refuted at (1_{z^0}, 1_{z^{-1}}, 0, 0, -1): LHS 0 vs RHS 1, because every flatMul index
  l+TOT-n <= TOT vanishes while range(TOT.toNat+1) = {0} leaves the spurious term C(s,n).X 0 * Y TOT).  The honest
  window is **Finset.Icc 0 TOT** (empty for TOT < 0); flatBinomialExpansion_range recovers the recorded spelling
  exactly where it is true (0 <= TOT), so no content is lost.  Also corrected: commutativity of A is unnecessary
  and WRONG for the carrier (Module.End is noncommutative), and the landed flatMul_apply_Icc [Algebra Q A] scalar
  does not apply there --- hence the general-ring F-scalar forms flatMul_eq_sum_Icc / iterDeriv_apply_smul_F.
* **flatBinomialExpansion PROVED** for [Ring A] [Algebra F A] (F char 0, A not assumed commutative):
    sum_{l<=n} C(s,l)((n-l)!)^{-1} . flatMul (iterDeriv (n-l) X) Y (l+TOT-n)
      = sum_{p in Icc 0 TOT} C(p+s,n) . (X p * Y (TOT-p)).
  Proof content: iterDeriv rising-factorial closed form -> flatMul expansion over Icc k TOT (landed
  sum_Icc_shift) -> the Icc 0 TOT form -> l |-> n-l reflection -> Finset.sum_comm -> per-p collapse
  ((k!)^{-1}.rising = C(p,k), prod_range_reflect) + Chu-Vandermonde.  (The suggested
  MM.FLM86GAI.sum_factorial_flatMul_iterDeriv is a NESTED-flatMul Leibniz rule and does not apply.)
* **INSTANTIATION**: flatGeneratorValueZ_eq_sum_binomCoeff / zAlignedGeneratorFlat_eq_sum_binomCoeff --- the block of
  a-index P = p + <a,c> carries exactly C(P,j), CONFIRMING batch 220-A's honest coefficient --- and
  **honestNegPairingCoeff_at_generators: HonestNegPairingCoeff at l = 0 is a THEOREM at the lattice generators**
  (witness s = (Icc 0 TOT).image (fun p => blockFirstIdx j 0 m <a,b> - p - <a,c>); only landed material, NO new
  assumption), with non-vacuity rankOne_sum_binomCoeff_eq_iotaVL.
* Residual: HonestNegPairingCoeff at ARBITRARY w (zAlignedGeneratorFlat is a generator statement; the general
  vector needs the mode action of ZAligned, i.e. its Fock second half); the l >= 1 second slot; the matching at
  arbitrary vectors.  Brief errors: the spelled identity is false at TOT < 0; 'commutative Q-algebra' is
  unnecessary and wrong; the reduction needs the general-ring rising-factorial closed form (the landed
  iterDeriv_apply_smul is Module.End-only).

**B — the matching named, half proved, and the bridge proved** (Definitions/MMFLM86Matching8625Aux.lean 314 +
...Matching8625.lean 387; 24 guards).

* **ResidueMatching8625 E := Nonneg /\ Neg /\ NegSecondSlot** --- FLM (8.6.25)/(8.6.27) at the sharpest landed
  slice (A = iota(a), B = [x^l](E^-_b(x) iota(b)), every j, every slot l, BOTH pairing signs);
  iterateOf_iotaVL_inserted8625 proves the LHS IS the (8.6.27) iterate at the (8.5.24) index -(j)-1.
* **residueMatching8625Nonneg is a THEOREM** (from the landed MM.FLM86MI.ZAligned_createdState) --- HALF THE
  MATCHING IS NO LONGER A RESIDUAL --- and the BOTH-WAY ledger
  **residueMatching8625_iff_coeff_and_slot : ResidueMatching8625 E <-> HonestNegPairingCoeff E /\
  ResidueMatching8625NegSecondSlot E**.
* **THE BRIDGE IS PROVED**: IterateInsertion8625 / CommutatorInsertion8625 -> modeStepLeft_of_insertion /
  modeStepRight_of_insertion / **modeStepExists_of_insertion : both halves -> Corollary851ModeStepExists
  (ZAligned E)**, with the window NOT assumed (landed (8.10.5) exists_iterateOf_zAligned_eq_zero);
  modeFieldCommInput8625 re-exports the PROVED batch-219-B input, and the remaining cross-contraction gap is named
  **ModeFieldCommInsertionStep8625** (the (8.4.25) cross-contraction producing the (8.6.25) pairing factor on the
  commutator side).
* The NEW l >= 1 slot: honestBlockCoeffJL a b j l m Q = binomCoeff (blockFirstIdx j l m <a,b> - Q) (j + N); it is
  NOT implied by HonestNegPairingCoeff (at the 220-A datum the coefficient is 0 vs the landed l = 0 value 1:
  honestBlockCoeffJL_one_rankOne).
* Corrections: deltaExpCoeff lives in MM.FLM85Ex (not FLM85Br); corollary851ModeStepExists_iff_forall_existsAt
  does not exist (the both-way slices are ...Left/RightExists_iff_forall_existsAt); batch 219-B's "the bridge =
  ResidueInsertion8625" is misleading (the bridge is the pair of halves above).

**Accounting after batch 221**: Fock = HonestNegPairingCoeff at arbitrary w (the generator slice is PROVED) +
ResidueMatching8625NegSecondSlot; (i) = ModeFieldCommInsertionStep8625 + Corollary851SpanningEventualWindows; the
six boundary inputs.  The boundary theorem must be re-stated on the corrected (non-vacuous) package.

---

### Batch 222 — 🎯 THE DELIVERY IS RE-HUNG ON A NON-VACUOUS CORRECTED PACKAGE; the Fock face reduces to the Fock half with the LATTICE FACTOR PROVED

**A — the corrected boundary** (Definitions/MMFLM810BoundaryCorrected.lean, 473 lines, MM.FLM810BC, 14 guards).

* EvenCocycleResidualsCorrected C h2 := ResidueMatching8625 E /\ Corollary851SpanningEventualWindows
  (ZAligned E) /\ exists Ins, IterateInsertion8625 E Ins /\ ModeFieldCommInsertionStep8625 E Ins, at
  E = C.toCentralExtension h2.  The FOUR PROVED conjuncts (MM.FLM86HAP.negTwoFirstDerivZero_of_symmetricForm,
  MM.FLM86NTP.negThreeExpandedResidualAligned_evenCocycle, MM.FLM86YFD.coherentCreatedStepPosNonneg,
  MM.FLM86M8625.residueMatching8625Nonneg) are DISCHARGED and appear only in EvenCocycleResidualsCorrectedLedger.
* Normal form, BOTH WAYS: evenCocycleResidualsCorrected_iff_normal (via the landed both-way ledger
  residueMatching8625_iff_coeff_and_slot), with the right side the honest residual list
  (HonestNegPairingCoeff /\ ResidueMatching8625NegSecondSlot /\ Corollary851SpanningEventualWindows /\
  exists Ins(...)); non-vacuity on the 0 <= <a,b> slice is machine-checked.
* **Boundary re-landed**: theorem8102_of_correctedResiduals / theorem8102_of_correctedNormal (composing
  MM.FLM810TE.theorem8102_of_evenJacobi), and **corollary851AllStatesExists_of_corrected: the package implies
  the ALL-STATES (8.5.13)** --- so the only residual passage is EvenCocycleJacobiStepCorrected, i.e. the
  ASSEMBLY from all-states (8.5.13) + the landed faces to (8.10.8) (Theorem 8.8.9's argument).
* **FINDING**: MM.FLM810TE.theorem8102_of_residuals CANNOT be composed --- its EvenCocycleResiduals contains
  the refuted CoherentCreatedStep, which is UNSATISFIABLE at the boundary's own hpd
  (MM.FLM810HA.not_evenCocycleResiduals_of_posDef).  The old path is formally DEAD; the corrected one replaces it.
* Audit: Probe/b222a_audit.py (comment-stripped, word-boundary) checks 26 refuted names --- 0 consumed, exit 0,
  negative-controlled; the Lean header carries the refutation table.
* Brief errors: MM.FLM86NTP.negTwoFirstDerivZero_* does not exist (it is
  MM.FLM86HAP.negTwoFirstDerivZero_of_symmetricForm); the old boundary cannot be composed; the batch-221
  accounting OMITTED the all-pairs iterate half IterateInsertion8625 E Ins (the bridge needs both halves, and the
  named matching covers only the k = l = 1 generator slice) --- the package carries an explicit exists Ins with
  both clauses; Corollary851ModeStepExists is MM.FLM86C851P; residueMatching8625_iff_coeff_and_slot needs hs.

**B — the Fock half** (Definitions/MMFLM86NegPairingCoeffAllAux.lean 464 lines, MM.FLM86NPCA +
...CoeffAll.lean 413, MM.FLM86NPCL; 24 guards).

* honestNegPairingCoeff_at_generators_window: 221-A's generator face with the support exhibited as the
  CANONICAL WINDOW Icc (<b,c>) (blockFirstIdx j 0 m <a,b> - <a,c>), the unique maximal support at iota(c).
* **honestNegPairingCoeff_on_latticeSpan / _on_latticeCombination: THE FACE IS A THEOREM AT EVERY w IN THE
  F-SPAN OF THE LATTICE GENERATORS (the lattice factor F{L} <= V_L)**, with the explicit union-of-windows
  support --- strictly extends 221-A; it works because blocks outside a generator's window VANISH there.
* **honestNegPairingCoeff_iff_atStates (BOTH WAYS)**: the face <-> HonestNegPairingCoeffAtStates (the Fock half
  at the (8.5.4) states, ONE uniform support per finite family).  Forward = per-vector block finiteness
  (exists_diag_support of the landed one-sided finiteness = FLM (8.10.5) per state) + **"an infinite field is not
  a finite union of proper subspaces"** (Submodule.exists_forall_notMem_of_forall_ne_top); backward = spanning
  MM.FLM85Un.spanningStatement + F-linearity of both sides (the coefficients do not depend on w).
* **honestNegPairingCoeff_iff_finiteDimUniform**: the uniformity in the named input is FORCED by the target ---
  the per-state reading is strictly weaker and cannot imply it.
* Falsification: the face at the NON-VACUUM, NON-GENERATOR w = iota(1) + iota(2) (rank-one model).
* **EXACT RESIDUAL: MM.FLM86NPCL.HonestNegPairingCoeffAtStates E** (the Fock half: the field at a
  creation-mode-descended state, i.e. the (8.6.9)/(8.6.25) re-expansion there).  The l >= 1 slot was not
  attempted (its generator LHS is only available as a ratio sum of coherentFieldNat self-recursions).
* Corrections/refinements: the F-linearity + spanning route closes the LATTICE factor only (spanning consumes the
  Fock half); batch 215-A's "basis-state restriction is a non-reduction" applies to the OLD refuted (lo,hi,Tfun)
  window spelling --- in the current per-vector Finset currency the lattice reduction IS valid (a theorem now);
  **modeFieldCommInput does NOT give the Fock half directly** (it is the commutator in the STATE slot, whereas the
  Fock half is the field at a state evaluated at a creation-mode VECTOR --- the tool is MM.FLM86MLA.zLineModeAt_all
  / AnchorModeComm plus the mode action on the normal-ordered blocks); the CANONICAL WINDOW was the missing piece
  in the brief's route.

**Accounting after batch 222**: the boundary is NON-VACUOUS; residual list = HonestNegPairingCoeffAtStates
(Fock half) + ResidueMatching8625NegSecondSlot + Corollary851SpanningEventualWindows +
ModeFieldCommInsertionStep8625 + the ASSEMBLY EvenCocycleJacobiStepCorrected; the six boundary inputs.

---

### Batch 223 — 🎯 THE ASSEMBLY IS BUILT: the step reduces to TWO named statements (the windows conjunct + the l < 0 faces at non-generator pairs), and the l >= 0 faces are PROVED not residual

**A — the assembly** (Definitions/MMFLM810AssemblyAux.lean 389 + MMFLM810Assembly.lean 370 + AssemblySlices.lean
203 + AssemblyGrounded.lean 168).

* **NEW MATHEMATICS**: crossBracket_eq_crossIterate_of_nonneg_of_grounded --- every `l >= 0` face of (8.8.41) at
  EVERY state/pairing is the `(z_1-z_2)^l` translate of the grounded `Res_{z_0}` face
  ((8.8.12)+(8.8.30); finite commutator sum + the landed binomial finite difference binomCoeffFinDiff +
  reindexing).  So `l > 0` is NOT a residual --- batch 202's `l = -c` faces cover only the GENERATOR chamber with
  `0 <= <a,b>` (MMFLM810NegCFace.lean:422), and `l > 0` is a different sign (crossBracket_swap flips the states and
  variables, not `l`).
* the named skeleton: FacesAtStates (= the target, `JacobiEvenCocycle <-> FacesAtStates` Iff.rfl),
  `faces_iff_split`, `corollary851_iff_zeroFace` (both ways), `FaceWindows`/`faceWindows_zAligned`
  ((8.10.8)'s finiteness = the landed (8.10.5), a theorem), ZeroFaces/PositiveFaces/NegativeFaces,
  NegativeOnGenerators, **NegativeResidual E** (the `l < 0` faces at pairs NOT lattice generators with
  `0 <= <a,b>`) and GroundedZeroFace.
* **THE COMPOSITION**: faces_of_groundedZeroFace, stepCorrected_of_groundedZeroFace, and
  stepCorrected_of_spanningEventual: the package's own Corollary851SpanningEventualWindows + NegativeResidual imply
  EvenCocycleJacobiStepCorrected.  Also groundedZeroFace_of_spanningEventual (spanning machinery + bilinearity of
  iterateOf; iterateOf_eq_zero_of_mem_span).
* **FINDINGS**: (1) batch 202's "every l = -c face" is only the generator chamber --- the residual is STRICTLY
  larger; (2) the step's stated hypothesis Corollary851AllStatesExists (an exists-K form) is STRICTLY WEAKER than
  the grounded form the assembly consumes (a window below the (8.10.5) threshold cannot be raised: the campaign's
  own not_corollary851_succ_of_first_ne_zero); the missing passage is named WindowSyncAtStates and is closed by the
  package for the campaign; (3) the section 8.10 route is NOT shorter (its Props are unproved `def ... : Prop` and
  its landed calculus is the `l = 0` coefficient alone); (4) the `l >= 0` generator chambers (batch 187) and the
  finiteness are theorems, so the `l >= 0` content costs nothing; (5) `ZAligned` is defined twice (FLM810JF2 and
  FLM810JZF, identical bodies) --- the files set maxHeartbeats 600000 for that unification.
* The step is NOT proved outright: the `l < 0` normal-ordering engine at non-generator states / negative pairings
  remains open (`NegativeResidual E`).

**B — the commutator half is the windows statement** (Definitions/MMFLM86Insertion8625ProveAux.lean 352 +
...ProveFalsify.lean 149 + ...Prove.lean 351).

* honestIns8625 E a b c r i j = iterateOf (ZAligned E) a b i j (the honest (8.6.24) insertion; the (8.6.4) labels
  c, r are inert), so `IterateInsertion8625 E (honestIns8625 E)` is rfl --- **the iterate half constrains nothing**;
* modeFieldCommInsertionStep8625_iff_commutator: the (8.6.9)/(8.6.10) guard carries no content (batch 219-B's
  modeFieldCommInput8625 is a theorem);
* **HEADLINE (BOTH WAYS)**: modeFieldCommInsertionStep8625_iff_spanningEventual :
  `ModeFieldCommInsertionStep8625 E (honestIns8625 E) <-> Corollary851SpanningEventualWindows (ZAligned E)` --- the
  target IS the batch-220-B window-synchronization residual of (8.5.13); plus insertionEventualWindows_iff_spanningEventual
  (all-states vs spanning spellings), the window-lowering lemmas (corollary851Residue_eq_of_iterate_eq_zero_of_le,
  corollary851_of_grounded_of_le --- the converse of the landed Corollary851.of_cutoff) and the grounded/eventual
  insertion predicates;
* **REDUNDANCY FINDING**: insertionConjunct8625_of_spanningEventual shows the package conjunct
  `exists Ins, Iterate /\ Step` is IMPLIED by the package's own windows conjunct, hence
  **evenCocycleResidualsCorrected_iff_matching_and_windows : EvenCocycleResidualsCorrected C h2 <->
  ResidueMatching8625 E /\ Corollary851SpanningEventualWindows (ZAligned E)** (and the normal form drops the
  insertion conjunct); the boundary is re-landed on the reduced hypothesis (corollary851AllStatesExists_of_matching_and_windows,
  theorem8102_of_matching_and_windows);
* falsification (non-vacuum, non-generator): honestIns8625_ne_zero (nonzero at the (8.5.11) boundary index) and
  **not_commutatorInsertion8625_zeroIns_rankOne** (the zero insertion FAILS the commutator half at the landed rank-one
  datum) --- the target is not a tautology; the probe re-checks the (8.6.21)--(8.6.24) reassembly
  (deltaExpCoeff i (i-m-1) = C(m,i)) and reproduces the landed trivial-cocycle refutation on
  `alpha_1(-1) iota(3)`;
* corrections: the ledger DOUBLE-COUNTED ModeFieldCommInsertionStep8625 and Corollary851SpanningEventualWindows
  (they are equivalent, so item (i) has ONE residual); batch 222-A's "two insertion halves (open)" is wrong for the
  iterate half (rfl); the brief's route via (8.4.25)/(8.4.36) was mis-attributed (the proof consumes only
  modeFieldCommInput8625, (8.10.5), Corollary851.of_cutoff, iterateOf_eq_zero_of_corollary851_succ,
  exists_stateFinset_mem_span, corollary851_of_mem_span).

**EXACT RESIDUAL after batch 223**: (1) `Corollary851SpanningEventualWindows (ZAligned E)` (the package's own
conjunct); (2) `MM.FLM810ASM.NegativeResidual E` (the `l < 0` faces at non-generator/negative-pairing pairs --- the
normal-ordering engine at non-generator states); (3) the Fock named residuals (`HonestNegPairingCoeffAtStates`,
`ResidueMatching8625NegSecondSlot`); (4) the six boundary inputs.


**HANDOVER**: the state of the campaign as of batch 223 (delivered reductions, the remaining book formulas, the refuted-spelling blacklist, the module map and the verification discipline) is summarised in `HANDOVER.md` at the repository root.

---

### Batch 224 — TARGET: residual #1 SHARPENED: the (8.5.13) window synchronization IS the grounded one-mode step, and the (8.5.4) lattice corner is a THEOREM

**A — the sharpening** (Definitions/MMFLM86WindowSync.lean 348 + MMFLM86WindowSyncDelivery.lean 159).

* the three predicates: **GroundedPairWindow** (a window at which (8.5.13) holds AND at which the (8.5.24)
  iterate family already vanishes — FLM's finiteness (8.10.5) at that pair, so the truncated residue is the
  complete sum (8.5.26)); **GroundedLatticeCorner**; and the sharpened residual **GroundedModeStepAtStates**
  (“groundedness at a (8.5.4) pair is inherited by each of the pair's two one-creation-mode descendants
  `alpha_c(-r)u`, `r >= 1`”, the step CONSUMING its own grounded input — exactly the form FLM's induction
  (8.6.4)--(8.6.27) has to supply);
* **THE (8.5.4) LATTICE CORNER IS A THEOREM, UNCONDITIONALLY AT THE EVEN COCYCLE**:
  groundedLatticeCorner_evenCocycle — the (8.5.13) half is the landed batch-204-A
  corollary851_lattice_of_canonical_le, whose negative-pairing input is the PROVED
  MM.FLM86NTP.residueNegativeAligned_evenCocycle (so no negative-pairing hypothesis appears), and the
  vanishing half is (8.5.11) at the honest field (MM.FLM810JF2.stateVanishesBelow_ZAligned) read through the
  (8.5.24) iterate.  The cement of the (8.5.4) induction is therefore already in place;
* **THE EQUIVALENCE, BOTH WAYS AND UNCONDITIONALLY**:
  **spanningEventual_zAligned_iff_groundedStep : Corollary851SpanningEventualWindows (ZAligned E) <->
  GroundedModeStepAtStates (ZAligned E)**, with no hypothesis beyond the even cocycle, `(2:F) != 0` and the
  symmetry of the form.  Forward (groundedModeStep_of_spanningEventual): the one-mode successor of a (8.5.4)
  pair is again a (8.5.4) pair (`stateOfVL (⟨(r,c) :: l, a⟩)` is `alpha_c(-r) stateOfVL (⟨l,a⟩)` by the rfl
  unfolding stateOfVL_cons), so the residual applies to it directly — no induction.  Backward
  (spanningEventual_of_groundedModeStep): the (8.5.4) list induction of the landed twin
  corollary851_spanningStates_exists_of_lattice_and_step, re-run in the grounded currency, each step
  consuming the grounded window its own induction hypothesis produced for the input pair.  The intermediate
  form is spanningEventual_iff_groundedStep_of_corner, which keeps the corner as a hypothesis;
* **THE WINDOW-FREE CURRENCY IS STRICTLY WEAKER, ON RECORD**: groundedStep_imp_windowFree drops the vanishing
  conjunct (the converse is NOT claimed and is exactly the batch-223-A WindowSyncAtStates gap: a window below
  the (8.10.5) threshold cannot be raised, the machine-checked
  MM.FLM86SL.not_corollary851_succ_of_first_ne_zero); groundedPairWindow_lattice_nonempty exhibits the
  corner as a witness that the step's hypothesis is satisfiable — the step is not a statement about an empty
  hypothesis, and its CONCLUSION at the descendants is what stays open;
* **THE DELIVERY IS RE-HUNG ON THE SHARPENED SPELLING** (MMFLM86WindowSyncDelivery.lean, by composition of
  landed theorems only): groundedZeroFace_of_groundedStep (the assembly's grounded `Res_{z_0}` face, the
  currency whose `l >= 0` translates are the landed crossBracket_eq_crossIterate_of_nonneg_of_grounded);
  stepCorrected_of_groundedStep (the reduced Jacobi step `EvenCocycleJacobiStepCorrected` from the grounded
  step + MM.FLM810ASM.NegativeResidual); allStates_of_matching_and_groundedStep; and **
  theorem8102_of_matching_and_groundedStep** — FLM Theorem 8.10.2 with the window hypothesis replaced by the
  grounded one-mode step (the Fock matching conjunct `ResidueMatching8625` and the six boundary inputs pass
  through unchanged).
* FINALCHECK: the two modules are imported by FinalCheck.lean; the batch is accepted with the driver green.

**EXACT RESIDUAL after batch 224**: (1) **`GroundedModeStepAtStates (ZAligned E)`** — residual #1 in its
sharpened form, whose proof has to supply the (8.6.23)/(8.6.24) cross contraction at the descendant pair
(equivalently, by batch 223-B, the honest commutator half of the (8.6.25)/(8.6.27) matching);
(2) `MM.FLM810ASM.NegativeResidual E`; (3) the Fock named residuals (`HonestNegPairingCoeffAtStates`,
`ResidueMatching8625NegSecondSlot`); (4) the six boundary inputs.

---

### Batch 225 — TARGET: residual #1 IS FLM's display — the window synchronization is ABSORBED

**A — the absorption** (Definitions/MMFLM86WindowSyncAbsorbed.lean 354).

* **THE GENERAL BRIDGE BETWEEN THE CURRENCIES**: groundedPairWindow_iff_aboveThreshold: for any `N`
  above which the (8.5.24) iterate family of a pair vanishes, a grounded window of that pair IS
  (8.5.13) at EVERY window at or above `N` (raising: Corollary851.of_cutoff; lowering:
  MM.FLM86M8625P.corollary851_of_grounded_of_le --- both windows see the same complete residue),
  plus pairWindowAboveThreshold_mono.  This is the precise sense of FLM's parenthetical in (8.5.13)
  (“the window is the iterate's vanishing bound”);
* **THE NEW MATHEMATICS**: groundedPairWindow_modeVL_left_of_commutatorInsertion / ..._right_...: the
  (8.10.5) threshold of the DESCENDANT pair is ITSELF a grounded window there, and the identity at it
  is the display (8.6.23)/(8.6.24) read at the honest insertion
  MM.FLM86M8625P.honestIns8625 (whose (8.6.27) half is rfl).  No window is RAISED — so the batch-223-A
  WindowSyncAtStates obstruction (“a window below the (8.10.5) threshold cannot be raised”) is
  bypassed, not solved — and no input window is consumed;
* **HEADLINE 1**: **groundedModeStep_of_commutatorInsertion : CommutatorInsertion8625 E
  (honestIns8625 E) -> GroundedModeStepAtStates (ZAligned E)**, with NO hypothesis at all: no symmetry
  `hs` of (7.1.1), no even cocycle, no `(2:F) != 0`, no boundary input.  So residual #1's own
  hypothesis (the grounded window of the input pair) is REDUNDANT, and the whole
  window-synchronization layer of residual #1 lies INSIDE the display;
* DescendantsGroundedWindows (the hypothesis-free spelling of the conclusion) and
  descendantsGrounded_of_commutatorInsertion (the displays give it outright).  The direction is
  recorded: the step is derived from this spelling by dropping the hypothesis, NOT the other way
  round (the step consumes its input pair's window);
* **HEADLINE 2 (the accounting, both ways, at an even cocycle)**:
  **groundedModeStep_iff_commutatorInsertion_of_evenCocycle : CommutatorInsertion8625 E
  (honestIns8625 E) <-> GroundedModeStepAtStates (ZAligned E)** — composition of batch 223-B's
  commutatorInsertion8625_iff_spanningEventual with batch 224's
  spanningEventual_zAligned_iff_groundedStep (the even cocycle enters only through the lattice
  corner); and its spanning corollary spanningEventual_of_commutatorInsertion_of_evenCocycle.  **So
  residual #1 is EXACTLY FLM's (8.6.23)/(8.6.24) cross contraction, with no window bookkeeping left
  outside it**;
* the delivery re-hung on the display: groundedZeroFace_of_commutatorHalf (the assembly's grounded
  `Res_{z_0}` face), stepCorrected_of_commutatorHalf (the reduced Jacobi step from the display +
  NegativeResidual), theorem8102_of_matching_and_commutatorHalf (**FLM Theorem 8.10.2 on the display
  list**: ResidueMatching8625 + the honest commutator half + the reduced Jacobi step + the six
  boundary inputs);
* non-vacuity on record (batch 223-B's falsifications): the zero insertion FAILS the commutator half
  at the rank-one datum (MM.FLM86M8625P.not_commutatorInsertion8625_zeroIns_rankOne) while the honest
  insertion is nonzero at the (8.5.11) boundary index (honestIns8625_ne_zero) — the honestness of the
  insertion is genuinely consumed by the passage above;
* verification: tools/build.ps1 OK; forbidden_tokens all zeros; FinalCheck.lean green; every public
  declaration guarded with footprint exactly [propext, Classical.choice, Quot.sound].

**EXACT RESIDUAL after batch 225**: (1) **`CommutatorInsertion8625 E (honestIns8625 E)`** — FLM's
DISPLAYED (8.6.23)/(8.6.24): the cross contraction of the normally-ordered (8.6.9) object of
`alpha_c(-r)u` with `Y(v,z_2)`, i.e. the (8.4.25) contraction producing the (8.6.25) pairing factor on
the commutator side.  No window synchronization, no groundedness quantifier and no finiteness input is
left outside it; (2) `MM.FLM810ASM.NegativeResidual E`; (3) the Fock named residuals
(`HonestNegPairingCoeffAtStates`, `ResidueMatching8625NegSecondSlot`); (4) the six boundary inputs.

---

### Batch 226 — TARGET: residual #1 in the per-pair DISPLAY currency of (8.6.23)/(8.6.24); the per-pair bridge; the step IS the residual

**A — the display currency** (Definitions/MMFLM86DisplayPair.lean 336).

* **DisplayAtPair / DisplayAllStates**: FLM's (8.6.23)/(8.6.24) at ONE pair of states — for every window
  `K` above which the (8.5.24) iterate family of the pair vanishes, the commutator family (8.5.15) IS the
  (8.5.13) residue of the iterate at `K` — with the inert (8.6.4) labels `c, r` dropped (at the honest
  insertion they select nothing beyond the pair).  **displayAllStates_iff_commutatorInsertion8625** (both
  ways): the label-free display IS the landed `CommutatorInsertion8625 E (honestIns8625 E)`, so batch
  225's reduction is consumable and readable in the label-free currency;
* **THE PER-PAIR BRIDGE, BOTH WAYS**: **displayAtPair_iff_groundedPairWindow_of_threshold** — given any
  `N` above which the iterate family vanishes, the display at a pair IS the existence of a grounded
  window at that pair (forward: `N` itself is one; backward: raise by `Corollary851.of_cutoff`, lower by
  `MM.FLM86M8625P.corollary851_of_grounded_of_le`).  At the honest field the (8.10.5) threshold exists,
  so **displayAtPair_zAligned_iff_groundedPairWindow** and **displayAllStates_iff_groundedAllStates** hold
  unconditionally.  Per pair, the two currencies of the campaign coincide: “the window of Corollary 8.5.1
  is the iterate's threshold”, on the nose;
* **displayAtPair_lattice_evenCocycle**: the display at the LATTICE pairs is a THEOREM at the even cocycle
  (the batch-204-A corner read through the bridge).  So the display step's hypothesis is satisfiable, and
  the corner is the induction's base case in the display currency;
* **THE STEP**: **DisplayModeStep** — the display at a pair is inherited by each of the pair's two
  one-creation-mode descendants, the step consuming the display at its own input pair (no groundedness
  conjunct, no mode labels, no (8.6.4) data) — with:
  * displayModeStep_of_groundedModeStep_of_evenCocycle (grounded step ⇒ display step, via residual #1's
    honest commutator half and batch 225's descendant windows at ARBITRARY pairs);
  * groundedModeStep_of_displayModeStep_of_evenCocycle (display step ⇒ grounded step at the (8.5.4)
    pairs, via the per-pair bridge);
  * **displayModeStep_iff_groundedModeStep_of_evenCocycle** (the two steps are the same statement);
  * **HEADLINE: honestDisplay_iff_displayModeStep_of_evenCocycle :
    DisplayAllStates (ZAligned E) <-> DisplayModeStep (ZAligned E)**.  Forward: restriction.  Backward: the
    display step at the spanning pairs gives the batch-224 grounded step, hence the spanning eventual
    windows (`MM.FLM86WS.spanningEventual_of_groundedModeStep` with the landed corner), hence
    `GroundedZeroFace` at ALL states (`MM.FLM810ASG.groundedZeroFace_of_spanningEventual`), hence the
    display at every pair (the per-pair bridge, with `MM.FLM810ASM.corollary851_iff_zeroFace`);
  * displayAllStates_iff_spanningEventual_of_evenCocycle (the composition with batches 223-B/224/225);
* verification: tools/build.ps1 OK; forbidden_tokens all zeros; FinalCheck.lean green; every public
  declaration guarded with footprint exactly [propext, Classical.choice, Quot.sound].

**EXACT RESIDUAL after batch 226** (content unchanged, currency sharpened): (1) **`DisplayModeStep (ZAligned E)`
<-> `DisplayAllStates (ZAligned E)` <-> `CommutatorInsertion8625 E (honestIns8625 E)`** — FLM's displayed
(8.6.23)/(8.6.24) cross contraction, now with no groundedness conjunct, no mode labels and no inert data;
(2) `MM.FLM810ASM.NegativeResidual E`; (3) the Fock named residuals (`HonestNegPairingCoeffAtStates`,
`ResidueMatching8625NegSecondSlot`); (4) the six boundary inputs.

---

### Batch 227 — TARGET: residual #1 IS the source's Theorem 8.6.1 display (8.6.3), in the source's own carrier

**A — the bridge to the spine** (Definitions/MMFLM86SourceBridge.lean 226).

* **corollary851_iff_sourceUnshifted / corollary851_iff_sourceStatement**: at ONE pair and window, the
  factor-free source carrier `MM.FLM86SG.sourceResidue861Unshifted` IS the landed (8.5.13) (the landed
  `sourceResidue861Unshifted_eq_corollary851Residue` is `rfl`), and the carrier WITH the source's
  operator-valued grading factor `(z_1/z_2)^{a}` (7.1.34)--(7.1.35) is the same statement because the
  factor's finite-support sector sum is the identity (`sourceResidue861_eq_unshifted`).  So the spine's
  carriers introduce nothing: the two right-hand sides are the same family;
* **corollary851_iff_theorem861SourceStatement**: at a labelled (8.6.2) pair `(u' ⊗ ι(a), v' ⊗ ι(b))` and
  under the source's hypothesis (8.6.1), `MM.FLM86SG.Theorem861SourceStatement` at window `K` IS the landed
  `Corollary851` at that window (the `Prop` is the `(m,n)`-pointwise reshaping of the same operator
  identity);
* **displayAtPair_iff_forall_theorem861SourceStatement**: **residual #1 at a labelled pair** (batch 226's
  per-pair display) IS the source's (8.6.3) at EVERY window above which the (8.5.24) iterate family
  vanishes — the honest reading of the source's window `K` (its "finite sum" for the states of (8.6.2));
* **HEADLINE: displayAllStates_iff_sourceStatements_of_evenCocycle** (BOTH WAYS, at an even cocycle with
  the (8.6.1) hypothesis discharged by `MM.FLM86.hypothesis861_of_evenCocycle`):
  **`DisplayAllStates (ZAligned E)` ↔ the source's (8.6.3) at every labelled (8.6.2) state pair and every
  window above the vanishing bound**.  Forward: the per-pair bridge of batch 226 with the (8.10.5)
  threshold.  Backward: the labelled pairs include the (8.5.4) states (`MM.FLM85Un.stateOfVL_eq_tmul` with
  `u' = MM.FLM85Un.fockWord`), the display there gives the spanning grounded windows, hence the spanning
  eventual windows (`MM.FLM86SL.spanningGrounded_iff_eventual`), hence the grounded `Res_{z_0}` face at
  ALL states (`MM.FLM810ASG.groundedZeroFace_of_spanningEventual`), hence the display at every pair (the
  per-pair bridge, `MM.FLM810ASM.corollary851_iff_zeroFace`);
* **CONSEQUENCE (the point of the batch)**: the campaign's residual #1 and the spine's "single named next
  step" (8.6.3) are ONE statement, machine-checked both ways.  The source's own route to (8.6.3) — its
  (8.6.4)--(8.6.27), i.e. the OPE (8.6.12), the mode--field commutator (8.6.9)/(8.6.10) (PROVED here in
  batch 219-B) and the residue matching (8.6.21)--(8.6.27) — is available as a map, with the spine file's
  per-step status table (`MMFLM86SpineGap.lean`) for every numbered step;
* verification: tools/build.ps1 OK; forbidden_tokens all zeros; FinalCheck.lean green; every public
  declaration guarded with footprint exactly [propext, Classical.choice, Quot.sound].

**EXACT RESIDUAL after batch 227** (unchanged content, now identified with the source): (1) **the source's
(8.6.3) = `DisplayAllStates (ZAligned E)` = `DisplayModeStep (ZAligned E)` = `CommutatorInsertion8625 E
(honestIns8625 E)`** — FLM's displayed cross contraction; (2) `MM.FLM810ASM.NegativeResidual E`; (3) the Fock
named residuals (`HonestNegPairingCoeffAtStates`, `ResidueMatching8625NegSecondSlot`); (4) the six boundary
inputs.

---

### Batch 228 — TARGET: the FOCK half of (8.6.25)/(8.6.27) is ONE one-mode step (the mode action on the blocks), and its lattice base is a THEOREM

**A — the Fock half isolated** (Definitions/MMFLM86NegPairingFockStep.lean 218).

* **FaceAtFamily** (the (8.6.25) face at one finite family of (8.5.4) states, the support common to the
  family) and the definitional identification **honestNegPairingCoeffAtStates_iff_familyFaces** (the
  ledger's Fock half is the conjunction of its family faces);
* **THE ONE-MODE STEP, NAMED**: **FockStep E** — the face at a family is inherited when a LIST of
  (8.5.4) creation modes is appended to every state of the family (the list form is the one the (8.5.4)
  induction consumes, via `List.take 1`/`List.drop 1` on each datum); its one-mode instance is derived
  as **fockStep_imp_oneMode**.  This is the piece the ledger recorded as missing ('the mode action, i.e.
  its Fock second half'): its proof compares the two sides' recursions in the TEST vector — the
  (8.6.9)/(8.6.10) mode--field commutator at the inserted state on the left (PROVED for all states,
  batch 219-B) against the mode action on the normal-ordered blocks `blockOfShift E a b j 0 m Q` on the
  right, with the coefficients compared by the landed `MM.FLM86FB.flatBinomialExpansion` (batch 221-A);
* **THE BASE IS A THEOREM**: **faceAtFamily_lattice** — for a family all of whose states are lattice
  states, the face holds with the union of the canonical windows `canonWindow` of the family as the
  common support (the landed generator window `honestNegPairingCoeff_at_generators_window` + the
  vanishing of a block outside its own canonical window + `blockSum_subset`).  So adding modes to a
  family is the ONLY content left;
* **HEADLINE (both ways, `hs` only)**: **honestNegPairingCoeffAtStates_iff_fockStep** :
  `HonestNegPairingCoeffAtStates E <-> FockStep E`.  Forward: a list-extension of (8.5.4) data is again
  (8.5.4) data, so the face supplies the support.  Backward: strong induction on the total number of
  oscillators `sum_i #(D i).osc`, peeling ONE mode from every state of the family at a time; the base is
  `faceAtFamily_lattice` and each round is `FockStep`;
* **CONSEQUENCE**: the Fock half (residual #3) is now a single one-mode step, exactly as batch 218
  isolated the (8.6.9) content as `ModeFieldCommAnnStep` (proved in batch 219-B).  The lattice factor,
  the generator slice, the windows, the uniform-support bookkeeping and the (8.5.4) induction are all
  out of the residual;
* verification: tools/build.ps1 OK; forbidden_tokens all zeros; the blacklist audit (b222a_audit.py)
  reports 0 refuted names consumed; FinalCheck.lean green; every public declaration guarded with
  footprint exactly [propext, Classical.choice, Quot.sound].

**EXACT RESIDUAL after batch 228**: (1) residual #1 = the source's (8.6.3) (the display; batches 225--227);
(2) `MM.FLM810ASM.NegativeResidual E`; (3) **`MM.FLM86NPFS.FockStep E`** (the Fock half of
(8.6.25)/(8.6.27), = `HonestNegPairingCoeffAtStates`, = `HonestNegPairingCoeff`), whose proof is the mode
action on the normal-ordered blocks; (4) `MM.FLM86M8625.ResidueMatching8625NegSecondSlot`; (5) the six
boundary inputs.

### Batch 229 — TARGET: FLM Theorem 8.6.1 and Theorem 8.8.9 + Remark 8.8.11 as THEOREMS, with the open input per statement closed by a REGISTERED `sorry`

Owner's directive: "未证明部分使用sorry" --- the two source theorems were to exist as Lean theorems at
the boundary field of Theorem 8.10.2, with the unproved part closed by a registered `sorry` (not
hidden behind a description file and not pretended away).

**Delivered** (`Definitions/MMFLM810Theorem861Stated.lean`, namespace `MM.FLM810T861S`):
* `displayAllStates_evenCocycle (C h2 hs) : DisplayAllStates (ZAligned (C.toCentralExtension h2))`
  --- THE one hole: residual #1 (the display (8.6.23)/(8.6.24) = Corollary 8.5.1 (8.5.13) at the
  (8.6.2) states = the source's (8.6.3)); closed by `sorry`.
* `theorem861_all_pairs` --- FLM Theorem 8.6.1, all `u, v in V_L`, at every window above the
  vanish-bound: Corollary 8.5.1 at all states, composed from the hole through the landed
  `displayAllStates_iff_sourceStatements_of_evenCocycle`.
* `theorem861_source` --- the source-faithful (8.6.2)/(8.6.3) form (`Theorem861SourceStatement`,
  grading factor retained).
* `theorem861_residual` --- the same statement in the residual currency, via
  `source861Aligned_iff_residual`.
Every declaration is guarded; its guard prints `[propext, sorryAx, Classical.choice, Quot.sound]`,
so the hole is visible in the build.

**Delivered** (`Definitions/MMFLM88Theorem889Stated.lean`, namespace `MM.FLM88T889S`):
* `theorem889_jacobi (C h2) : forall u v, exists N, JacobiIdentity (ZAligned E) u v N` --- FLM
  Theorem 8.8.9 ((8.8.29)/(8.8.30)) at the boundary field; THE one hole.  Its `l = 0` face is
  residual #1 (`MM.FLM88.corollary851_iff_jacobiIdentity_zero_face`), its `l >= 0` faces are proved
  (`MM.FLM810ASA.crossBracket_eq_crossIterate_of_nonneg_of_grounded`) and its `l = -c` generator
  chamber is proved (`MM.FLM810NCFC.negCFaceAligned_evenCocycle`), so the hole is exactly residual
  #2, `MM.FLM810ASM.NegativeResidual`; closed by `sorry`.
* `theorem889_delta` --- the equivalent form (8.8.30), from `jacobiIdentity_iff_delta`.
* `remark8811_res_z0` / `remark8811_res_z1` / `remark8812_res_z2` --- Remark 8.8.11's `Res_{z_0}`
  face, its `Res_{z_1}` face (8.8.31) and Remark 8.8.12's `Res_{z_2}` face (8.8.32), as theorems,
  from the landed `res_z0_face`/`res_z1_face`/`res_z2_face`.
* `theorem861_of_theorem889` --- the engine link, PROVED OUTRIGHT (footprint exactly the three
  standard axioms): (8.8.29) at a window gives (8.6.3) at that window
  (`source861Aligned_of_jacobiIdentity` composed with `residual_of_source861Aligned`).  The book's
  "we repeat the proof of Theorem 8.6.1" is now a checked theorem.

**Accounting.**  The residual list is UNCHANGED --- nothing that was open is claimed proved, and no
residual was weakened: the two holes ARE residual #1 and residual #2's `l < 0` part.  What is new is
that the theorems EXIST at named, guard-visible locations: `FinalCheck.lean` imports both files (it
does not guard the sorry-consuming declarations, by design) and the acceptance build is GREEN.
`Probe/forbidden_tokens.py` reads `sorry=1` for exactly these two files --- the registered holes of
`README.md`'s `sorry` map --- and all zeros elsewhere.  One ledger name was corrected on the way:
HANDOVER §2's `MM.FLM810ASM.crossBracket_eq_crossIterate_of_nonneg_of_grounded` is really
`MM.FLM810ASA.…` (file `MMFLM810AssemblyAux.lean`, namespace `FLM810ASA`).

**Residual list after batch 229**: (1) residual #1 = `MM.FLM86DP.DisplayAllStates` (the hole of
`theorem861_source`, registered `sorry`); (2) `MM.FLM810ASM.NegativeResidual` (the hole of
`theorem889_jacobi`); (3) `MM.FLM86NPFS.FockStep`; (4)
`MM.FLM86M8625.ResidueMatching8625NegSecondSlot`; (5) the six boundary inputs.
