0fbcce429b
Implements ADR-0182's first win on top of EX-6 (#473). The distractor-quantity confuser 0014 misfired (20x3x5=300) because a blunt product-of-all was the *unique* self-verifying reading: the completeness clause forces the distractor into it, and no rival reading existed to trigger the wrong=0 disagreement rule. No tight cue rule separates it from the legitimate cross-unit products (`for` licenses both the 0014 distractor AND the correct train-0021 product) -- that is the deferred cue-precision problem. So instead of a reactive patch, let the disagreement rule do the refusing. Mechanism (sealed lane; chat/ does not import these -> serving 3/47/0 frozen): - verify.classify_derivation: a derivation is `complete` (commit-eligible), `exempt` (verified but for an isolated-foreign unused quantity -> commit- INELIGIBLE), or None. Refactored self_verifies into _base_reasons + _unused_quantities so the two share logic and cannot drift (behavior identical; 385 derivation tests + smoke 67 green). - accumulate.accumulation_candidates: exposes the ungated readings, incl. a distractor-skip reading that drops an isolated-foreign quantity from a multi- quantity change clause (20+5=25). compose_accumulation is byte-identical (drop_isolated_foreign=False + the same gate). - search.multiplicative_candidates / multistep.candidate_chains: ungated candidates. - pool.resolve_pooled: pools every composer's readings; disagreement -> refuse; a single answer commits only if a `complete` candidate produced it (exempt-only -> refuse, so the commit-path completeness guarantee from ADR-0175 is untouched). - confuser runner: _engine_answer now delegates to resolve_pooled (the prior first-composer-wins order could not notice it held two incompatible readings). Result (the microscope): - confuser wrong 5 -> 2. distractor 0014 refuses (product 300 vs additive 25); BONUS: both disguised-polarity cases (0001/0003) refuse -- the spurious "buys X for N coins" product disagrees with the accumulation reading. Remaining wrong: 0016 (distractor in the anchor clause -> needs anchor-skip, separate step) and 0020 (temporal-scope). pair-tells 4 -> 1. - genuine positives still 7 solved, 0 wrong. - train_sample 3/47/0 and practice 3/47/0 byte-identical (they call compose_accumulation/search directly -- unchanged -- not the pool). - smoke 67, architectural invariants 40, lane-SHA freeze 8/8. Tests: - test_adr_0182_pool.py: classify (complete/exempt/None incl. narrow-exemption edges) + resolve_pooled, with the wrong=0 obligation test_exempt_only_never_commits (a distractor with no multiplicative cue must refuse, not commit 25 -- fails loudly if the exemption is made commit-eligible). - test_adr_0163_f2_confusers.py: baseline tightened wrong 5->2, pair_tells 4->1; new test_distractor_0014_refuses_via_pooling + test_disguised_polarity_does_not_misfire. Stacked on #473 (EX-6); merge #473 first. 0016 + the remaining wrongs are follow-ups.
88 lines
3.8 KiB
Python
88 lines
3.8 KiB
Python
"""ADR-0182 — cross-composer disagreement pooling.
|
|
|
|
The distractor-quantity confusers (``confuser-v1-0014`` → 300, ``0016`` → 3840)
|
|
misfire because a blunt product-of-all is the *unique* self-verifying reading: the
|
|
completeness clause forces the distractor into it, and no rival reading exists to
|
|
trigger the wrong=0 disagreement rule. The microscope showed no tight cue/gate rule
|
|
separates these from the legitimate cross-unit products (``for`` licenses both the
|
|
0014 distractor and the correct ``train-0021`` product) — that is the deferred
|
|
cue-precision problem (ADR-0177).
|
|
|
|
This module sidesteps cue precision: it pools the **ungated candidate readings of
|
|
every composer** (accumulation, in-clause multiplicative, target-guided chain) for
|
|
one problem and resolves them together. A reading is classified
|
|
(:func:`generate.derivation.verify.classify_derivation`) as ``complete``
|
|
(commit-eligible) or ``exempt`` (commit-INELIGIBLE — verified but for an
|
|
isolated-foreign *distractor* quantity it leaves unused). The rule:
|
|
|
|
* candidates disagree (more than one distinct answer across the pool) → **refuse**
|
|
(the wrong=0 disagreement rule does the work);
|
|
* a single distinct answer → commit **only if** a ``complete`` candidate produced it
|
|
(an ``exempt``-only answer never commits — full completeness is still required to
|
|
resolve, so ADR-0175's multi-step-incomplete defence is untouched).
|
|
|
|
For a distractor problem this gives the product (``complete``) a competing additive
|
|
reading (``exempt``) to disagree with → refusal; for a genuine product (0021/0003)
|
|
there is no rival reading, so it still commits. Deterministic; sealed (serving is
|
|
never invoked here).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from generate.derivation.accumulate import accumulation_candidates
|
|
from generate.derivation.model import GroundedDerivation
|
|
from generate.derivation.multistep import candidate_chains
|
|
from generate.derivation.search import multiplicative_candidates
|
|
from generate.derivation.verify import Resolution, classify_derivation
|
|
|
|
|
|
def pooled_candidates(problem_text: str) -> list[GroundedDerivation]:
|
|
"""Every composer's ungated candidate readings, de-duplicated. Deterministic
|
|
order (accumulation, then multiplicative, then chain)."""
|
|
seen: set[tuple[object, ...]] = set()
|
|
pooled: list[GroundedDerivation] = []
|
|
for derivation in (
|
|
*accumulation_candidates(problem_text),
|
|
*multiplicative_candidates(problem_text),
|
|
*candidate_chains(problem_text),
|
|
):
|
|
key = (
|
|
round(derivation.answer, 9),
|
|
derivation.start.source_token,
|
|
tuple((step.op, step.operand.source_token) for step in derivation.steps),
|
|
)
|
|
if key in seen:
|
|
continue
|
|
seen.add(key)
|
|
pooled.append(derivation)
|
|
return pooled
|
|
|
|
|
|
def resolve_pooled(problem_text: str) -> Resolution | None:
|
|
"""Resolve a problem by pooling every composer's readings. Refuse-preferring.
|
|
|
|
Refuses on no verifying candidate, on disagreement among the pool, or when the
|
|
sole answer is produced only by commit-ineligible (``exempt``) readings.
|
|
"""
|
|
classified = [
|
|
(kind, derivation)
|
|
for derivation in pooled_candidates(problem_text)
|
|
if (kind := classify_derivation(derivation, problem_text)) is not None
|
|
]
|
|
if not classified:
|
|
return None
|
|
|
|
distinct = {round(derivation.answer, 9) for _, derivation in classified}
|
|
if len(distinct) != 1:
|
|
return None # disagreement -> refuse (wrong=0)
|
|
|
|
committable = [d for kind, d in classified if kind == "complete"]
|
|
if not committable:
|
|
return None # exempt-only -> refuse (a commit requires full completeness)
|
|
|
|
chosen = committable[0]
|
|
return Resolution(
|
|
answer=chosen.answer,
|
|
answer_unit=chosen.answer_unit,
|
|
derivation=chosen,
|
|
)
|