core/docs/research/compare-multiplicative-increment-plan-2026-07-18.md

Increment Plan — compare_multiplicative (reader arc, increment 1)

Status: APPROVED with four amendments (PR #76 ruling, folded below); X = 15 ratified as the arc's escalation threshold. Build proceeds under this ruling — no separate re-ruling. Date: 2026-07-18 Base: forgejo/main @ dd1e4670 (dev2 spike + errata merged, #75) Branch: feat/compare-mult-increment-plan Arc: reader, design-first — per-family increments in lockstep (docs/research/dev2-frontier-measurement-spike-2026-07-18.md §7). This is increment 1; compare_multiplicative jumps the queue because the reader already emits real parses for it.

---

1. The increment (both halves, one PR)

Per §7.1 the increment lands a grammar family in Reader A + its matching compiler tier, in lockstep, as one smoke-gated PR carrying a measured holdout_dev delta, wrong=0 held, sealed test untouched. The two halves cannot move separately — proof below: the 5 real compare parses exist today and die at the compiler (corridor 0/500).

2. Ground truth — the 5 real compare parses (holdout_dev)

Every one has the same shape: one entity seeded, the other defined by the comparison, unknown = total.

id	shape	gold
0101	Eduardo=3; Frankie = 2×Eduardo; total	9
0108	Newport=22; Dana = 4×Newport; total	110
0411	female=13; male = 3×female; total	52
0453	dad=7; Olaf = 3×dad; total	28
0268	Bruce=4; Michael = 3×Bruce; total	16

compare_multiplicative op carries Comparison(reference_actor, factor, direction ∈ {times,fraction}): actor_quantity = factor × reference_actor_quantity (ADR-0123). All 5 have unknown.entity = None → the existing certified summation turn (ADR-0250 2b) closes them once the compare op is solvable.

3. Compiler tier — compare_multiplicative (evals/multi_register_program.py)

A cross-register affine definition: actor := factor × reference. Reuses the quantity kernel and the multi-register framework; two things are new and must be designed explicitly:

• Reads one register, writes another. Today's per-register ops read+write the same register. Compile the op to: transport the reference register's field STATE by a dilator (dilate(ref_state, −ln factor)), relax to it, and write the result into the actor register. Anti-hollow: transport the reference state, never a decoded value.
• The actor is defined, not seeded. In all 5, the actor has no initial_state possession — the comparison introduces the register. The executor must admit a register first written by a compare op (today it seeds only from initial_state).
• No conservation pin. A transfer moves quantity (Σ conserved, hard-reject); a comparison creates a related quantity (Σ is not conserved by design). The conservation pin applies to transfers only; compare ops are exempt — stated, not silently skipped.
• direction='fraction' (factor < 1, "half as many as") is the same dilator with factor < 1 — folded in. compare_additive (more/fewer, a translator) is a later increment (frequency order §7.2).

Expected immediate effect: corridor real-reach 0/500 → the compare parses that already exist — the §7.2 "loop works end-to-end on official data" proof. Two amendments (PR #76) make this correct rather than "unchanged":

3.1 Summation becomes registers-driven (AMENDMENT 1 — new code, not a confirmation)

The certified summation turn today orders by program.seeds, which come from initial_state. A compare-defined register has no seed, so as currently coded it would be silently excluded from the total — and all 5 real cases are totals. Fix: the summation sums all registers present at solve time, in a deterministically pinned order (seed order, then definition order). Compile-side validation must admit defined entities as answer targets (a total or a concrete unknown may be a compare-defined register), with unit propagation from the reference (the defined register inherits the reference's unit). Pin test: a compare-defined register appears in the certified sum.

3.2 The compare record (AMENDMENT 2 — specify before build)

Cross-register provenance must live in the chain so deterministic re-verification can reconstruct which register fed the dilation from records alone (same reasoning as the summation-ruling). The compare_multiplicative record: identifies the reference entity, and binds the reference state's digest via the existing conditional operand_source_digest (present only on cross-register records, so non-compare/non-summation record digests stay byte-identical). Verification re-derives the source register from the record and checks the dilation reproduces.

4. Reader grammar family — broaden compare_multiplicative parsing

Today the reader emits compare_multiplicative for ~5/500 — narrow phrasings only ("double what", "four times the number of", "three times as many/more"). Frontier incidence (spike §3) puts compare_multiplicative markers in ~20% of official problems (~100/500), so the reader captures ~5% of the compare surface. The grammar family broadens the compare templates (e.g. "twice as … as", "N times as much/many as", "N times the number/amount of", "half/a third as many as") — measured by how many more official problems parse to a correct compare graph. Reader work lives in the generate/math_candidate_* parser; this half is where most of the coverage delta comes from.

"N times more than" — pinned convention (AMENDMENT 4). The grammar family reads "N times more than X" as N×X (not (N+1)×X), fixed as an explicit disclosed convention — the ambiguity is real, so the reading is a stated choice, not an assumption. Every gold mismatch attributable to this reading is tracked as a recorded finding (never a silent wrong); if the corpus systematically means (N+1)×, the record will show it and the convention flips on evidence.

Honest scope: this increment solves problems whose only frontier kind is compare_multiplicative (plus basic ops + summation). Multi-frontier problems (spike §3: 16/100 carry ≥2 markers) wait for their other families' increments — recorded, not counted here.

5. Measurement protocol (§7.5 constraints, verbatim)

• Signal = official holdout_dev only — never the authored corpus.
• wrong=0 is the floor — a compare parse counts only if compile → execute → gold agrees.
• Sealed test (1,319) untouched.
• Disjoint split, pinned deterministically FIRST (AMENDMENT 3). Before any grammar work, the 500 holdout_dev cases are partitioned by a deterministic protocol — sha256(id)-ordered assignment (e.g. even/odd rank → tune / measure), documented in the plan and fixed in advance. The reader grammar is tuned only against the tune split; the increment's delta is measured only on the disjoint measure split. Disjointness is only as strong as its enforcement, so it is committed before a line of grammar changes — "better" can only mean "generalizes."
• Delta reported = new-correct on the measured split; the increment must clear X = 15 (ratified, spike §7.3) or it triggers a practice-lane ruling. Compare incidence (~20%) means a paying reader family should convert well above 15.

6. Risks / open decisions (post-amendment)

1. "N times more than" — resolved to a pinned N× convention with tracked mismatches (§4, AMENDMENT 4).
2. Garbled entity spans (0268's actor is a run-on string) — cosmetic today (answer still correct), but the reader family should tighten entity extraction; a wrong entity binding could mis-route a compare in a 3-entity problem. Remaining open risk.
3. Compare-then-op ordering — if a defined register is later transferred/scaled, the compare must resolve first; the executor already runs ops in story order, so this is a test to pin, not new code.
4. Register-introduced-by-compare in the total — reclassified: this is new code, not a confirmation (§3.1, AMENDMENT 1). Summation is registers-driven with a pinned order; a defined register that is the answer target propagates its unit from the reference.

7. Increment PR (what ships next, under this ruling)

One smoke-gated PR: the compiler tier (§3, including §3.1 registers-driven summation + §3.2 compare record) + the reader grammar family (§4) + tests + the measured delta. Test set:

• the 5 real parses solved end-to-end, wrong=0;
• compare-defined register appears in the certified sum (§3.1 pin);
• defined-entity answer target with unit propagated from the reference (§3.1);
• compare record re-verification — source register reconstructed from records alone (§3.2);
• no-conservation-on-compare; fraction direction;
• N× convention pinned, mismatches surfaced as findings (§4);
• the deterministic tune/measure split fixed before grammar work (§5, AMENDMENT 3);
• the measured holdout_dev measure-split delta recorded against X = 15.

Nothing else in it. Build proceeds now under this ruling.