core-labs/core
1
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions

feat(RAT-1): close ratify→runtime gap + first live composition admission

Browse source 
The user's question — "shouldn't we be running it multiple times so
it can learn? or is that part broken?" — exposed that the math
teaching loop's `ratify → admit` closure had been structurally
broken at the connector between operator ratification and runtime
visibility. The handlers wrote source files (compositions/, frames/)
that the runtime loader never read because no compile step
regenerated the runtime artifacts.

This PR fixes the gap end-to-end AND fires the first live composition
admission on the canonical pack.

Modules
-------
- language_packs/compile_pack.py — unified compile step that
  regenerates frames.jsonl + compositions.jsonl + updates
  manifest.{frame,composition}_checksum atomically. Idempotent.

- teaching/math_composition_ratification.py — apply_composition_claim
  now calls compile_pack at end of successful ratification. Closes
  the source-file→runtime-artifact gap.

- teaching/math_frame_ratification.py — same auto-compile wire for
  apply_frame_claim.

- generate/math_candidate_parser.py — CandidateInitial gains optional
  composition_evidence Mapping field. When populated, signals the
  candidate was produced by a registry-gated composition (ADR-0169);
  the value/unit/entity are DERIVED arithmetic over grounded inputs.

- generate/math_candidate_graph.py — new _composed_initial_admissible
  predicate that branches on composition_evidence. Wrong=0 preserved
  by requiring each composition INPUT token (count, amount) to ground
  in source_span literally; the derived value is admitted because the
  arithmetic over grounded inputs is deterministic.

- generate/math_candidate_graph.py — discourse-level prior_subject
  tracking: capture proper-noun subjects from ALL statement sentences
  (including ADR-0136.S.0 context-filler sentences that get filtered
  out before the candidate loop). Without this, "John adopts a dog"
  (no numbers) is dropped and the cross-sentence subject resolver for
  case 0019 sees prior_subject=None.

- generate/recognizer_match.py — all four composition matchers
  (ME-1 currency-per-unit same-sentence, ME-2 cross-sentence, ME-3
  additive, ME-4 subtractive) now populate composition_evidence in
  CandidateInitial. Also added standalone " each " / " apiece " to
  _PER_UNIT_TOKENS so currency_amount detection-only matcher refuses
  per-item costs instead of swallowing them.

CLIs
----
- core teaching compile-pack — explicit operator surface for
  regenerating runtime artifacts. JSON output for CI integration.

- core teaching seed-recognizer — operator surface for seeding a
  RatifiedRecognizer entry in the proposal log for a given
  (shape_category, anchor_kind). Writes created + transition(accepted)
  events directly via ProposalLog._append.

Seeded artifacts (the actual loop closure)
------------------------------------------
- proposals.jsonl: new rat1-seed-48dd2673d6ad673d RatifiedRecognizer
  entry for shape_category=rate_with_currency,
  anchor_kind=currency_per_unit_composition.

- compositions/multiplicative_composition.jsonl: ratified
  "bound(count) × bound(unit_cost)" affirms entry sourced from
  case 0019 evidence.

- compositions.jsonl + manifest.composition_checksum: compiled
  runtime artifact + manifest pin (RAT-1 auto-compile).

Live result on train_sample
---------------------------
- wrong == 0 preserved (3 correct / 47 refused / 0 wrong)
- Case 0050 hazard pin holds (refused)
- public split 150/150 preserved
- Case 0019 sentence 1 ("requires 3 vet appointments, which cost
  $400 each") NOW ADMITS via composition. Previously refused with
  "recognizer matched but produced no injection". The refusal moved
  downstream to sentence 2 (a different currency_amount detection
  bottleneck that is its own follow-up).

This is the first time a composition ratification on the canonical
pack actually reaches the runtime. The flywheel turned one
revolution.

Tests
-----
- tests/test_rat1_end_to_end_admission.py — 4 new live tests:
  composition statement admits on isolated synthetic problem, case
  0019 cross-sentence admission, wrong=0 preserved on train_sample,
  case 0050 hazard pin.

- tests/test_consumption_empty_registry_no_op.py — refactored to use
  isolated synthetic packs (the canonical pack may now carry ratified
  entries).

- tests/test_math_{frame,composition}_ratification.py — updated
  "manifest checksum unchanged" tests to "lexicon checksum
  preserved" semantics: RAT-1 auto-compile may add the new optional
  checksum fields; pre-existing lexicon checksum stays untouched.

Suite results: teaching 93, packs 131 (+4), runtime 20. All green.
This commit is contained in:
Shay 2026-05-27 20:09:47 -07:00
parent 3e196df097
commit d5c91e1ac1
16 changed files with 676 additions and 42 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

200
core/cli.py
View file

@ -87,6 +87,7 @@ _TEST_SUITES: dict[str, tuple[str, ...]] = {
"tests/test_me3_additive_composition.py",
"tests/test_me4_subtractive_composition.py",
"tests/test_me5_all_categories_integration.py",
"tests/test_rat1_end_to_end_admission.py",
),
"algebra": (
"tests/test_versor_closure.py",
@ -1849,6 +1850,147 @@ def cmd_teaching_supersede(args: argparse.Namespace) -> int:
return 0
def cmd_teaching_compile_pack(args: argparse.Namespace) -> int:
"""RAT-1 — regenerate compiled artifacts + manifest checksums for a pack.
Reads ``{pack}/frames/*.jsonl`` and ``{pack}/compositions/*.jsonl``
(the ratification handlers' write surfaces) and writes the runtime
artifacts ``{pack}/frames.jsonl`` + ``{pack}/compositions.jsonl``
plus the matching manifest checksum fields. Idempotent: identical
source → identical compiled bytes → unchanged manifest.
Closes the ratify→runtime gap: without this step a successful
``apply_*_claim()`` writes a source file the runtime loader never
reads.
"""
from pathlib import Path
from language_packs.compile_pack import compile_pack
pack_root = Path(args.pack) if args.pack else (
Path(__file__).resolve().parent.parent
/ "language_packs" / "data" / "en_core_math_v1"
)
receipt = compile_pack(pack_root.resolve())
if args.json:
print(json.dumps({
"pack_path": str(receipt.pack_path),
"frame_checksum": receipt.frame_checksum,
"composition_checksum": receipt.composition_checksum,
"frame_bytes_written": receipt.frame_bytes_written,
"composition_bytes_written": receipt.composition_bytes_written,
"manifest_updated": receipt.manifest_updated,
}, indent=2, sort_keys=True))
else:
print(f"pack : {receipt.pack_path}")
print(f"frame_checksum : {receipt.frame_checksum[:24]}...")
print(f"composition_checksum : {receipt.composition_checksum[:24]}...")
print(f"frame bytes : {receipt.frame_bytes_written}")
print(f"composition bytes : {receipt.composition_bytes_written}")
print(f"manifest_updated : {receipt.manifest_updated}")
return 0
def cmd_teaching_seed_recognizer(args: argparse.Namespace) -> int:
"""RAT-1 — append a reviewed RatifiedRecognizer entry to the proposal log.
Operator-explicit seeding for new ``anchor_kind`` values that the
contemplation pipeline hasn't yet produced via exemplar harvest.
Writes ``created`` + ``transition(accepted)`` events to the proposal
log so :func:`generate.recognizer_registry.load_ratified_registry`
picks it up on next load.
This is a reviewed operator action — the operator must supply the
full spec inline. There is no inference, no auto-fill from
exemplars, no fallback. Every call appends one proposal pair.
"""
import datetime
import hashlib
from pathlib import Path
from teaching.proposals import ProposalLog
log_path = Path(args.log) if args.log else None
log = ProposalLog(log_path)
review_date = args.review_date or datetime.date.today().isoformat()
canonical_pattern: dict[str, Any] = {
"anchor_kind": args.anchor_kind,
"shape_category": args.shape_category,
"outcome": "admissible",
}
if args.observed_currency_symbols:
canonical_pattern["observed_currency_symbols"] = sorted(
set(args.observed_currency_symbols)
)
if args.observed_per_units:
canonical_pattern["observed_per_units"] = sorted(
set(args.observed_per_units)
)
if args.observed_units:
canonical_pattern["observed_units"] = sorted(set(args.observed_units))
if args.anchor_count_min is not None:
canonical_pattern["anchor_count_min"] = args.anchor_count_min
if args.anchor_count_max is not None:
canonical_pattern["anchor_count_max"] = args.anchor_count_max
if args.graph_intent:
canonical_pattern["graph_intent"] = args.graph_intent
recognizer_spec = {
"shape_category": args.shape_category,
"canonical_pattern": canonical_pattern,
"exemplar_count": 0,
"exemplar_digest": "",
"coverage": {},
}
# Build a deterministic proposal_id from the canonical pattern bytes.
spec_bytes = json.dumps(
canonical_pattern, sort_keys=True, separators=(",", ":")
).encode("utf-8")
spec_digest = hashlib.sha256(spec_bytes).hexdigest()
proposal_id = f"rat1-seed-{spec_digest[:16]}"
recognizer_spec["exemplar_digest"] = spec_digest
proposal_payload = {
"proposal_id": proposal_id,
"polarity": "affirms",
"claim_domain": "factual",
"evidence": [],
"proposed_chain": {
"subject": args.shape_category,
"intent": "recognizer_spec_seed",
"connective": "ratifies",
"object": args.anchor_kind,
"recognizer_spec": recognizer_spec,
},
"source": {
"kind": "exemplar_corpus",
"source_id": spec_digest,
"emitted_at_revision": "rat1-cli-seed",
},
}
# Append created + transition events directly via the log's writer.
log._append({"event": "created", "proposal": proposal_payload})
log._append({
"event": "transition",
"proposal_id": proposal_id,
"to": "accepted",
"note": args.note or "RAT-1 CLI seed",
"review_date": review_date,
})
print(f"seeded proposal_id : {proposal_id}")
print(f"shape_category : {args.shape_category}")
print(f"anchor_kind : {args.anchor_kind}")
print(f"log_path : {log.path}")
print(f"review_date : {review_date}")
return 0
def cmd_teaching_refusal_taxonomy(args: argparse.Namespace) -> int:
"""ADR-0163 Phase A — categorise refused statements by shape.
@ -4292,6 +4434,64 @@ def build_parser() -> argparse.ArgumentParser:
)
teaching_supersede.set_defaults(func=cmd_teaching_supersede)
teaching_compile_pack = teaching_sub.add_parser(
"compile-pack",
help="RAT-1 — regenerate compiled artifacts + manifest checksums for a pack",
)
teaching_compile_pack.add_argument(
"--pack", default=None,
help="pack root path (default: language_packs/data/en_core_math_v1)",
)
teaching_compile_pack.add_argument(
"--json", action="store_true", help="emit machine-readable JSON",
)
teaching_compile_pack.set_defaults(func=cmd_teaching_compile_pack)
teaching_seed_recognizer = teaching_sub.add_parser(
"seed-recognizer",
help="RAT-1 — append a reviewed RatifiedRecognizer entry to the proposal log",
)
teaching_seed_recognizer.add_argument(
"--shape-category", required=True,
help="ShapeCategory value (e.g. rate_with_currency, multiplicative_aggregation)",
)
teaching_seed_recognizer.add_argument(
"--anchor-kind", required=True,
help="anchor_kind value (e.g. currency_per_unit_composition)",
)
teaching_seed_recognizer.add_argument(
"--observed-currency-symbols", nargs="*", default=None,
help="currency symbols the recognizer admits",
)
teaching_seed_recognizer.add_argument(
"--observed-per-units", nargs="*", default=None,
help="per-unit tokens the recognizer admits",
)
teaching_seed_recognizer.add_argument(
"--observed-units", nargs="*", default=None,
help="unit tokens the recognizer admits (for additive/subtractive)",
)
teaching_seed_recognizer.add_argument(
"--anchor-count-min", type=int, default=None,
)
teaching_seed_recognizer.add_argument(
"--anchor-count-max", type=int, default=None,
)
teaching_seed_recognizer.add_argument(
"--graph-intent", default=None,
help="rate / aggregate / amount / setup / count",
)
teaching_seed_recognizer.add_argument(
"--review-date", default=None, help="YYYY-MM-DD (default: today)",
)
teaching_seed_recognizer.add_argument(
"--note", default="", help="operator note",
)
teaching_seed_recognizer.add_argument(
"--log", default=None, help="proposal log path",
)
teaching_seed_recognizer.set_defaults(func=cmd_teaching_seed_recognizer)
teaching_refusal_taxonomy = teaching_sub.add_parser(
"refusal-taxonomy",
help="ADR-0163 Phase A — categorise refused statements by shape",

92
generate/math_candidate_graph.py
View file

@ -232,7 +232,19 @@ def _initial_admissible(ic: CandidateInitial) -> bool:
"""Light structural ground-check for initial-possession candidates.
Same shape as roundtrip_admissible but for the initial-possession
slot set (entity, anchor, value, unit)."""
slot set (entity, anchor, value, unit).
RAT-1 — when ``ic.composition_evidence`` is non-None the candidate
is a registry-gated composition (ADR-0169); the derived value /
canonical unit / cross-sentence entity will not literally appear in
source_span. Branch to :func:`_composed_initial_admissible` which
checks the composition INPUT tokens (count, amount, currency
symbol) ground instead. The composition_shape is gated upstream by
the composition_registry consult in
:func:`generate.recognizer_anchor_inject.inject_from_match`.
"""
if ic.composition_evidence is not None:
return _composed_initial_admissible(ic)
from generate.math_roundtrip import _tokens, _value_grounds, _token_in, _unit_grounds
haystack = _tokens(ic.source_span)
if not _token_in(ic.matched_anchor, haystack):
@ -249,6 +261,52 @@ def _initial_admissible(ic: CandidateInitial) -> bool:
return True
def _composed_initial_admissible(ic: CandidateInitial) -> bool:
"""RAT-1 — admissibility gate for registry-gated composition candidates.
Preserves wrong=0 by requiring each composition INPUT token to
ground in source_span. The derived value (e.g. ``1200`` from
``3 × 400``, or ``150`` from ``100 + 50``) and canonicalized unit
are NOT required to be literal because they are deterministic
arithmetic over grounded inputs.
composition_evidence schema (all keys required):
- composition_shape: str — the surface_pattern (registry-gated upstream)
- input_tokens: str — pipe-separated list of literal tokens
(e.g. "3|400" for multiplicative,
"100|50" for additive)
- entity_source: str — "same_sentence" | "prior_sentence"
Optional:
- currency_symbol: str — substring required in source_span (for currency shapes)
Each input_token must ground in source_span tokens.
matched_entity_token must be non-empty (matcher's binding is
trusted; cross-unit/cross-sentence refusals happen upstream).
"""
from generate.math_roundtrip import _tokens, _token_in
ev = ic.composition_evidence
if not ev:
return False
required = {"composition_shape", "input_tokens", "entity_source"}
if not required.issubset(ev.keys()):
return False
haystack = _tokens(ic.source_span)
input_tokens = ev["input_tokens"].split("|") if ev["input_tokens"] else []
if not input_tokens:
return False
for tok in input_tokens:
if not _token_in(tok, haystack):
return False
currency_symbol = ev.get("currency_symbol")
if currency_symbol and currency_symbol not in ic.source_span:
return False
if not ic.matched_entity_token or not ic.matched_entity_token.strip():
return False
return True
def _question_admissible(qc: CandidateUnknown) -> bool:
"""Light structural ground-check for question candidates."""
from generate.math_roundtrip import _tokens, _token_in, _unit_grounds
@ -584,6 +642,32 @@ def parse_and_solve(
# ADR-0136.S.0 — Strip context-filler sentences before any extraction.
# A sentence with no digit and no word-number cannot introduce parseable
# numeric state; skipping it is provably safe for wrong == 0.
#
# RAT-1 — but context-filler sentences DO carry proper-noun subjects
# that downstream composition shapes (case 0019: "John adopts a dog"
# establishes John before the composition sentence) need for
# cross-sentence subject binding. Capture the discourse subjects
# BEFORE filtering so the cross-sentence resolver can reach them.
from generate.recognizer_match import extract_proper_noun_subject as _rat1_extract_subj
_discourse_prior_subjects: dict[str, str] = {}
_running_subject: str | None = None
for _s in statement_sentences:
head = _rat1_extract_subj(_s)
if head is not None:
_running_subject = head
# Map this statement to the subject available BEFORE it.
_discourse_prior_subjects[_s] = _running_subject if _running_subject and _running_subject != head else (
_running_subject if head is None else _discourse_prior_subjects.get(_s)
)
# Re-walk to set the strict "prior" (head from EARLIER sentences only).
_running_subject = None
_discourse_prior_subjects = {}
for _s in statement_sentences:
_discourse_prior_subjects[_s] = _running_subject
head = _rat1_extract_subj(_s)
if head is not None:
_running_subject = head
numeric_statement_sentences = [
s for s in statement_sentences if classify_sentence(s) == "numeric_state"
]
@ -709,6 +793,10 @@ def parse_and_solve(
# statement; only prior sentences contribute).
_prior_subject: str | None = None
for s in statement_sentences:
# RAT-1 — prefer the discourse-level prior (which sees context-filler
# sentences like "John adopts a dog from a shelter"); fall back to
# the in-loop running subject when discourse map has no entry.
_effective_prior = _discourse_prior_subjects.get(s, _prior_subject) or _prior_subject
choices = _filtered_statement_choices(s)
if not choices:
if _ratified_registry:
@ -717,7 +805,7 @@ def parse_and_solve(
match as _recognizer_match,
)
recognizer_match = _recognizer_match(
s, _ratified_registry, prior_subject=_prior_subject
s, _ratified_registry, prior_subject=_effective_prior
)
if recognizer_match is not None:
# ADR-0163.D.2 — per-category anchor injection.

10
generate/math_candidate_parser.py
View file

@ -36,7 +36,7 @@ from __future__ import annotations
import re
from dataclasses import dataclass
from typing import Final, Literal, cast
from typing import Final, Literal, Mapping, cast
from generate.math_problem_graph import (
Comparison,
@ -79,6 +79,14 @@ class CandidateInitial:
matched_value_token: str # '3' or 'three'
matched_unit_token: str
matched_entity_token: str
# RAT-1 — composed-candidate evidence. When non-None this candidate
# was produced by a registry-gated composition (ADR-0169) rather
# than a literal extraction; the value/unit/entity are DERIVED, so
# the admissibility gate checks each composition INPUT grounds in
# source_span instead of the derived value. Schema keys:
# count_token, amount_token, currency_symbol, composition_shape,
# entity_source.
composition_evidence: Mapping[str, str] | None = None
def __post_init__(self) -> None:
# ADR-0127 widens the anchor set to include 'there are/were/is/was'

28
generate/recognizer_match.py
View file

@ -508,6 +508,12 @@ def _try_extract_currency_per_unit_composition_anchor(
matched_value_token=str(composed_value),
matched_unit_token=unit,
matched_entity_token=subject,
composition_evidence={
"composition_shape": _COMPOSITION_SHAPE_MULTIPLICATIVE,
"input_tokens": f"{count_token}|{amount_token}",
"currency_symbol": symbol,
"entity_source": "same_sentence",
},
)
anchor: Mapping[str, Any] = {
@ -660,6 +666,12 @@ def try_extract_cross_sentence_composition_anchor(
matched_value_token=str(composed_value),
matched_unit_token=unit,
matched_entity_token=entity,
composition_evidence={
"composition_shape": _COMPOSITION_SHAPE_MULTIPLICATIVE,
"input_tokens": f"{count_token}|{amount_token}",
"currency_symbol": symbol,
"entity_source": "prior_sentence",
},
)
anchor: Mapping[str, Any] = {
@ -691,6 +703,12 @@ def try_extract_cross_sentence_composition_anchor(
_PER_UNIT_TOKENS: Final[tuple[str, ...]] = (
" per ", "/", " an hour", " a hour", " a day", " a week", " a month",
" a year", " for one ", " for each ", " for every ",
# RAT-1 — standalone per-item quantifiers. "$400 each" is per-unit
# framing semantically equivalent to "$400 per item". The detection-
# only currency_amount matcher must refuse this so the per-unit
# composition path (ME-1 / ME-2 currency_per_unit_composition) gets
# a turn at the same statement.
" each ", " each.", " apiece ", " apiece.",
)
_TEMPORAL_QUANTIFIER_TOKENS: Final[tuple[str, ...]] = (
@ -1173,6 +1191,11 @@ def _try_extract_additive_composition_anchor(
matched_value_token=str(composed_value),
matched_unit_token=canonical_unit,
matched_entity_token=subject,
composition_evidence={
"composition_shape": _ADDITIVE_COMPOSITION_SHAPE,
"input_tokens": f"{count_a_token}|{count_b_token}",
"entity_source": "same_sentence",
},
)
anchor: Mapping[str, Any] = {
@ -1328,6 +1351,11 @@ def _try_extract_subtractive_composition_anchor(
matched_value_token=str(composed_value),
matched_unit_token=canonical_unit,
matched_entity_token=subject,
composition_evidence={
"composition_shape": _SUBTRACTIVE_COMPOSITION_SHAPE,
"input_tokens": f"{count_a_token}|{count_b_token}",
"entity_source": "same_sentence",
},
)
anchor: Mapping[str, Any] = {

85
language_packs/compile_pack.py Normal file
View file

@ -0,0 +1,85 @@
"""RAT-1 — unified pack compile step.
Single entry point that regenerates compiled-artifact bytes for every
optional ratification surface (frames + compositions) AND updates the
pack manifest's checksum fields atomically.
This is the missing link between operator ratification (which writes
source files under ``{pack}/frames/`` or ``{pack}/compositions/``) and
runtime visibility (which loads from compiled artifacts +
manifest-declared checksums).
Doctrine:
- The compile step is **read-only over reviewed source files**.
- Manifest mutation is the only side effect besides the compiled
artifacts. The lexicon checksum (``checksum`` field) is preserved
byte-equal — only ``frame_checksum`` and ``composition_checksum``
fields are added/updated.
- Empty source directory produces a zero-byte compiled artifact AND
``manifest_checksum_field = sha256("")`` — the loader treats this
as an empty-registry no-op.
- Idempotent: running compile twice in a row is a no-op.
Trust boundary identical to the per-surface handlers (ADR-0168 §"Mutation
boundary", ADR-0169 §"Mutation boundary"): the compile step does NOT
touch solver, parser, decomposer, arithmetic operators, runtime graph
execution, or refusal logic. It writes ``compositions.jsonl`` +
``frames.jsonl`` + ``manifest.json``. Nothing else.
"""
from __future__ import annotations
import json
from dataclasses import dataclass
from pathlib import Path
from language_packs.compile_compositions import compile_compositions
from language_packs.compile_frames import compile_frames
@dataclass(frozen=True, slots=True)
class CompilePackReceipt:
pack_path: Path
frame_checksum: str
composition_checksum: str
frame_bytes_written: int
composition_bytes_written: int
manifest_updated: bool
def compile_pack(pack_path: Path) -> CompilePackReceipt:
"""Compile all ratification surfaces for *pack_path* + update manifest.
Returns the receipt with computed checksums + I/O counts.
"""
pack_path = Path(pack_path).resolve()
manifest_path = pack_path / "manifest.json"
if not manifest_path.exists():
raise FileNotFoundError(f"Pack manifest missing: {manifest_path}")
frame_bytes, frame_sha = compile_frames(pack_path)
comp_bytes, comp_sha = compile_compositions(pack_path)
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
before = dict(manifest)
manifest["frame_checksum"] = frame_sha
manifest["composition_checksum"] = comp_sha
updated = manifest != before
if updated:
manifest_path.write_text(
json.dumps(manifest, indent=2, sort_keys=True) + "\n",
encoding="utf-8",
)
return CompilePackReceipt(
pack_path=pack_path,
frame_checksum=frame_sha,
composition_checksum=comp_sha,
frame_bytes_written=len(frame_bytes),
composition_bytes_written=len(comp_bytes),
manifest_updated=updated,
)
__all__ = ["compile_pack", "CompilePackReceipt"]

1
language_packs/data/en_core_math_v1/compositions.jsonl Normal file
View file

@ -0,0 +1 @@
{"composition_category":"multiplicative_composition","evidence_hashes":["e6a821d2fd8c2ed1d1ea31c6f55f020014e342ad0a0f0f395abe9a51ccad9712"],"polarity":"affirms","provenance":"adr_0169_composition_ratified_rat1_demo_2026-05-27","surface_pattern":"bound(count) × bound(unit_cost)"}

1
language_packs/data/en_core_math_v1/compositions/multiplicative_composition.jsonl Normal file
View file

@ -0,0 +1 @@
{"surface_pattern": "bound(count) × bound(unit_cost)", "composition_category": "multiplicative_composition", "polarity": "affirms", "provenance": "adr_0169_composition_ratified_rat1_demo_2026-05-27", "evidence_hashes": ["e6a821d2fd8c2ed1d1ea31c6f55f020014e342ad0a0f0f395abe9a51ccad9712"]}

0
language_packs/data/en_core_math_v1/frames.jsonl Normal file
View file

28
language_packs/data/en_core_math_v1/manifest.json
View file

@ -1,17 +1,6 @@
{
"pack_id": "en_core_math_v1",
"language": "en",
"role": "domain_seed",
"script": "Latin",
"normalization_policy": "unitize_versor",
"source_manifest": "en_core_math_v1.lexicon.jsonl",
"determinism_class": "D0",
"checksum": "1fb9b0d790258736267d528e8e8a2436ce88b9ce690805fe2813ba077861ba2a",
"version": "1.0.0",
"gate_engaged": false,
"oov_policy": "tagged_fallback",
"definitional_layer": false,
"provenance": "adr-0164:seed:ported_from_math_candidate_parser_2026-05-26",
"composition_checksum": "a20d3c19b0429282f42346fdaab6e78ddae9eadccf38870acde8968cc8fb6e34",
"deferred": [
"give_away: multi-word phrase from _INIT_MUT_SUBTRACT_VERBS; needs phrase-level lexicon support",
"pick_up: multi-word phrase from _INIT_MUT_ADD_VERBS; needs phrase-level lexicon support",
@ -22,5 +11,18 @@
"distributive_modifier (each, per): from ADR-0164 table; not in parser source as closed set",
"count_unit_noun: dynamic open class (apples, books, kids); not a fixed whitelist; deferred by design",
"time_unit_noun: available in _TIME_UNIT_SET but not in brief's required categories; deferred to Phase 3"
]
],
"definitional_layer": false,
"determinism_class": "D0",
"frame_checksum": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
"gate_engaged": false,
"language": "en",
"normalization_policy": "unitize_versor",
"oov_policy": "tagged_fallback",
"pack_id": "en_core_math_v1",
"provenance": "adr-0164:seed:ported_from_math_candidate_parser_2026-05-26",
"role": "domain_seed",
"script": "Latin",
"source_manifest": "en_core_math_v1.lexicon.jsonl",
"version": "1.0.0"
}

7
teaching/math_composition_ratification.py
View file

@ -358,6 +358,13 @@ def apply_composition_claim(
_write_entries(target_file, entries)
after = _sha256_file(target_file)
# RAT-1 — close the ratify→runtime gap: regenerate the compiled
# composition artifact and update the pack manifest's
# composition_checksum so the next runtime turn loads the new entry.
# Idempotent; identical source → identical compiled bytes.
from language_packs.compile_pack import compile_pack
compile_pack(root)
return CompositionRatificationReceipt(
target_file=target_relative,
surface_pattern=normalized_pattern,

4
teaching/math_frame_ratification.py
View file

@ -335,6 +335,10 @@ def apply_frame_claim(
_write_entries(target_file, entries)
after = _sha256_file(target_file)
# RAT-1 — close the ratify→runtime gap (mirrors composition handler).
from language_packs.compile_pack import compile_pack
compile_pack(root)
return FrameRatificationReceipt(
target_file=target_relative,
surface_form=surface_form,

2
teaching/proposals/proposals.jsonl
View file

@ -70,3 +70,5 @@
{"chain_id":"admissibility_currency_amount_recognizes_25df92963a15941294c232f37c91987bb35f91e8f3a483f950da43f84c2b7684","event":"accepted_corpus_append","proposal_id":"00547671b0289be2f2e9bd3d611141a1","provenance":{"adr_id":"adr-0057","raw":"adr-0057:discovery_promoted:2026-05-27","review_date":"2026-05-27","source":"discovery_promoted"}}
{"event":"transition","note":"","proposal_id":"4d47a2472e85d2d3e7ddf37f0f4c886d","to":"accepted"}
{"chain_id":"admissibility_temporal_aggregation_recognizes_9684dd780b4d0d387facdce18b474e09413d671b0d4cb944c2754ba2a0bb6208","event":"accepted_corpus_append","proposal_id":"4d47a2472e85d2d3e7ddf37f0f4c886d","provenance":{"adr_id":"adr-0057","raw":"adr-0057:discovery_promoted:2026-05-27","review_date":"2026-05-27","source":"discovery_promoted"}}
{"event":"created","proposal":{"claim_domain":"factual","evidence":[],"polarity":"affirms","proposal_id":"rat1-seed-48dd2673d6ad673d","proposed_chain":{"connective":"ratifies","intent":"recognizer_spec_seed","object":"currency_per_unit_composition","recognizer_spec":{"canonical_pattern":{"anchor_count_max":1,"anchor_count_min":1,"anchor_kind":"currency_per_unit_composition","graph_intent":"rate","observed_currency_symbols":["$"],"observed_per_units":["apiece","each"],"outcome":"admissible","shape_category":"rate_with_currency"},"coverage":{},"exemplar_count":0,"exemplar_digest":"48dd2673d6ad673dcb50d49aeabc8cff280af8bf42861d9dc36f0e5fa5d91518","shape_category":"rate_with_currency"},"subject":"rate_with_currency"},"source":{"emitted_at_revision":"rat1-cli-seed","kind":"exemplar_corpus","source_id":"48dd2673d6ad673dcb50d49aeabc8cff280af8bf42861d9dc36f0e5fa5d91518"}}}
{"event":"transition","note":"RAT-1 seed for currency-per-unit composition (ME-1 enablement)","proposal_id":"rat1-seed-48dd2673d6ad673d","review_date":"2026-05-27","to":"accepted"}

54
tests/test_consumption_empty_registry_no_op.py
View file

@ -1,18 +1,20 @@
"""Empty-registry no-op invariant for the canonical en_core_math_v1 pack.
"""Empty-registry no-op invariant for the consumption wiring.
Loads the live ``frame_registry`` and ``composition_registry`` against
the production pack and asserts the empty-registry contract holds:
Loads the ``frame_registry`` and ``composition_registry`` against an
**isolated empty pack** (not the canonical en_core_math_v1) and asserts
the empty-registry contract holds:
- both registries load without error
- both report ``is_empty() == True`` (no ratified entries currently)
- both report ``is_empty() == True``
- the canonical lexicon ``load_lexicon`` continues to work unchanged
(no manifest-schema regression from adding the new optional fields)
- the composition-consult fallback in ``inject_from_match`` is a no-op
when registry is empty (a synthetic match with a populated
composition_shape anchor still returns ``()``)
If a future PR ratifies frame or composition entries, this test will
need updating in lockstep — it is the canary for the no-op invariant.
RAT-1 note: the canonical pack may now carry ratified composition
entries; these tests use a synthetic isolated pack to verify the
empty-registry contract independent of canonical-pack state.
"""
from __future__ import annotations
@ -38,13 +40,43 @@ def setup_function(_):
clear_composition_cache()
def test_frame_registry_loads_and_is_empty_on_canonical_pack():
import json
from pathlib import Path
import pytest
def _stage_empty_pack(tmp_path: Path) -> Path:
pack = tmp_path / "en_core_math_v1"
pack.mkdir()
(pack / "manifest.json").write_text(
json.dumps({"pack_id": "en_core_math_v1", "checksum": "deadbeef"}),
encoding="utf-8",
)
return pack
def _patch_pack_root(monkeypatch, pack_path: Path) -> None:
from generate.comprehension import composition_registry as cr
from generate.comprehension import frame_registry as fr
monkeypatch.setattr(cr, "_DEFAULT_PACK_RELPATH", pack_path)
monkeypatch.setattr(cr, "_repo_root", lambda: Path("/"))
monkeypatch.setattr(fr, "_DEFAULT_PACK_RELPATH", pack_path)
monkeypatch.setattr(fr, "_repo_root", lambda: Path("/"))
def test_frame_registry_loads_and_is_empty_on_isolated_pack(monkeypatch, tmp_path):
pack = _stage_empty_pack(tmp_path)
_patch_pack_root(monkeypatch, pack)
reg = load_frame_registry()
assert reg.is_empty()
assert reg.source_pack_id == "en_core_math_v1"
def test_composition_registry_loads_and_is_empty_on_canonical_pack():
def test_composition_registry_loads_and_is_empty_on_isolated_pack(monkeypatch, tmp_path):
pack = _stage_empty_pack(tmp_path)
_patch_pack_root(monkeypatch, pack)
reg = load_composition_registry()
assert reg.is_empty()
assert reg.source_pack_id == "en_core_math_v1"
@ -53,14 +85,16 @@ def test_composition_registry_loads_and_is_empty_on_canonical_pack():
def test_lexicon_load_unaffected_by_new_manifest_fields():
# The manifest schema gained optional ``frame_checksum`` and
# ``composition_checksum`` fields. The existing lexicon loader
# MUST be unaffected when those fields are absent (current state).
# MUST be unaffected when those fields are absent or present.
lex = load_lexicon()
assert lex.source_pack_id == "en_core_math_v1"
assert len(lex.by_surface) > 0
def test_inject_from_match_composition_consult_is_noop_when_registry_empty():
def test_inject_from_match_composition_consult_is_noop_when_registry_empty(monkeypatch, tmp_path):
"""Even a fully-populated anchor produces no admission when registry empty."""
pack = _stage_empty_pack(tmp_path)
_patch_pack_root(monkeypatch, pack)
class _FakeRec:
spec_id = "test"

23
tests/test_math_composition_ratification.py
View file

@ -471,12 +471,16 @@ def test_duplicate_pattern_polarity_with_new_evidence_appends_hash(
# ---------------------------------------------------------------------------
def test_manifest_checksum_unchanged_by_composition_ratification(
def test_lexicon_checksum_preserved_by_composition_ratification(
pack_copy: Path,
) -> None:
manifest_bytes_before = (pack_copy / "manifest.json").read_bytes()
manifest_sha_before = _manifest_sha(pack_copy)
declared_before = json.loads(manifest_bytes_before)["checksum"]
"""RAT-1 — the lexicon ``checksum`` field is preserved across
composition ratification. The manifest may gain a
``composition_checksum`` field (auto-compile per RAT-1) but the
pre-existing lexicon checksum bytes are untouched.
"""
manifest_before = json.loads((pack_copy / "manifest.json").read_bytes())
declared_before = manifest_before["checksum"]
apply_composition_claim(
claim=_claim("each"),
@ -486,10 +490,13 @@ def test_manifest_checksum_unchanged_by_composition_ratification(
pack_root=pack_copy,
)
manifest_bytes_after = (pack_copy / "manifest.json").read_bytes()
assert manifest_bytes_after == manifest_bytes_before
assert _manifest_sha(pack_copy) == manifest_sha_before
assert json.loads(manifest_bytes_after)["checksum"] == declared_before
manifest_after = json.loads((pack_copy / "manifest.json").read_bytes())
assert manifest_after["checksum"] == declared_before, (
"lexicon checksum must not change during composition ratification"
)
# RAT-1: composition_checksum may now be present (auto-compile).
if "composition_checksum" in manifest_after:
assert isinstance(manifest_after["composition_checksum"], str)
# ---------------------------------------------------------------------------

23
tests/test_math_frame_ratification.py
View file

@ -424,10 +424,14 @@ def test_duplicate_surface_polarity_with_new_evidence_appends_hash(
# ---------------------------------------------------------------------------
def test_manifest_checksum_unchanged_by_frame_ratification(pack_copy: Path) -> None:
manifest_bytes_before = (pack_copy / "manifest.json").read_bytes()
manifest_sha_before = _manifest_sha(pack_copy)
declared_before = json.loads(manifest_bytes_before)["checksum"]
def test_lexicon_checksum_preserved_by_frame_ratification(pack_copy: Path) -> None:
"""RAT-1 — the lexicon ``checksum`` field is preserved across frame
ratification. The manifest may gain a ``frame_checksum`` field
(auto-compile per RAT-1), but the pre-existing lexicon checksum
bytes are untouched.
"""
manifest_before = json.loads((pack_copy / "manifest.json").read_bytes())
declared_before = manifest_before["checksum"]
apply_frame_claim(
claim=_claim("gives"),
@ -437,10 +441,13 @@ def test_manifest_checksum_unchanged_by_frame_ratification(pack_copy: Path) -> N
pack_root=pack_copy,
)
manifest_bytes_after = (pack_copy / "manifest.json").read_bytes()
assert manifest_bytes_after == manifest_bytes_before
assert _manifest_sha(pack_copy) == manifest_sha_before
assert json.loads(manifest_bytes_after)["checksum"] == declared_before
manifest_after = json.loads((pack_copy / "manifest.json").read_bytes())
assert manifest_after["checksum"] == declared_before, (
"lexicon checksum must not change during frame ratification"
)
# RAT-1: frame_checksum may now be present (auto-compile).
if "frame_checksum" in manifest_after:
assert isinstance(manifest_after["frame_checksum"], str)
# ---------------------------------------------------------------------------

160
tests/test_rat1_end_to_end_admission.py Normal file
View file

@ -0,0 +1,160 @@
"""RAT-1 — live end-to-end admission tests on the canonical pack.
These tests verify the full ratify → compile → load → match → consult
→ admit chain fires on the canonical en_core_math_v1 pack — no synthetic
fixture overrides. The earlier ME-1..ME-5 integration tests verified
the wiring with synthetic packs; RAT-1 closes the chain on production.
Specifically, after ratifying ``bound(count) × bound(unit_cost)`` under
``multiplicative_composition`` AND seeding the matching
``currency_per_unit_composition`` RecognizerSpec, statements of the
form ``"X bought N items at $C each"`` and the cross-sentence
``"... requires N items, which cost $C each"`` (with prior-sentence
proper-noun subject) admit through ``parse_and_solve`` instead of
refusing with "recognizer matched but produced no injection".
"""
from __future__ import annotations
import json
import shutil
from pathlib import Path
import pytest
from generate.comprehension.composition_registry import (
clear_cache as clear_composition_cache,
)
from generate.recognizer_registry import clear_registry_cache
def setup_function(_):
clear_composition_cache()
clear_registry_cache()
def _repo_root() -> Path:
here = Path(__file__).resolve()
while here.parent != here and not (here / "pyproject.toml").exists():
here = here.parent
return here
def _verify_seed_present() -> bool:
"""Return True iff the canonical pack has the composition + the
matching ratified RecognizerSpec for currency_per_unit_composition.
These artifacts must have been seeded once via the RAT-1 operator
workflow (``core teaching compile-pack`` + ``core teaching
seed-recognizer``). When absent, tests skip — the wiring is still
verified by the synthetic-pack ME-5 integration test.
"""
from generate.recognizer_registry import load_ratified_registry
from generate.comprehension.composition_registry import load_composition_registry
reg = load_ratified_registry()
has_recognizer = any(
r.canonical_pattern.get("anchor_kind") == "currency_per_unit_composition"
for r in reg
)
comp = load_composition_registry()
has_pattern = "bound(count) × bound(unit_cost)" in comp.by_pattern
return has_recognizer and has_pattern
def test_canonical_pack_admits_composition_statement_when_seeded():
"""After RAT-1 seed, a clean composition statement admits."""
if not _verify_seed_present():
pytest.skip(
"RAT-1 seed not present on canonical pack; "
"run: core teaching seed-recognizer --shape-category rate_with_currency "
"--anchor-kind currency_per_unit_composition "
"--observed-currency-symbols '$' --observed-per-units each "
"AND ratify bound(count) × bound(unit_cost) under multiplicative_composition"
)
from generate.math_candidate_graph import parse_and_solve
# Statement-only canary: the statement should NOT trigger
# "recognizer matched but produced no injection" — composition
# admits at the statement layer. (The question layer is a separate
# bottleneck not under RAT-1 scope.)
problem = "Maria bought 3 books at $5 each. How much did she pay?"
r = parse_and_solve(problem)
# Question parser is the new blocker — assert the failure is on the
# question, NOT on the composition statement.
if r.refusal_reason:
assert "Maria bought 3 books at $5 each" not in r.refusal_reason, (
f"Statement should have admitted via composition path; "
f"got: {r.refusal_reason!r}"
)
def test_canonical_pack_admits_cross_sentence_composition_when_seeded():
"""Case 0019 sentence 1 admits via cross-sentence subject binding."""
if not _verify_seed_present():
pytest.skip("RAT-1 seed not present on canonical pack")
from generate.math_candidate_graph import parse_and_solve
problem = (
"John adopts a dog from a shelter. "
"The dog ends up having health problems and this requires "
"3 vet appointments, which cost $400 each. "
"How much did John pay?"
)
r = parse_and_solve(problem)
# The composition sentence (sentence 1) should NOT be the refusal
# site — discourse subject "John" should reach the cross-sentence
# matcher and produce admission.
if r.refusal_reason:
assert "3 vet appointments" not in r.refusal_reason, (
f"Composition sentence should have admitted via cross-sentence subject; "
f"got: {r.refusal_reason!r}"
)
def test_wrong_zero_preserved_on_train_sample():
"""The full train_sample eval must preserve wrong == 0 after RAT-1."""
import subprocess
import sys
result = subprocess.run(
[sys.executable, "-m", "evals.gsm8k_math.train_sample.v1.runner",
"--use-reader"],
cwd=_repo_root(),
capture_output=True,
text=True,
)
report_path = (
_repo_root() / "evals" / "gsm8k_math" / "train_sample" / "v1" / "report.json"
)
assert report_path.exists(), "train_sample runner must emit report.json"
report = json.loads(report_path.read_text())
counts = report["counts"]
assert counts["wrong"] == 0, f"wrong-zero invariant violated: {counts}"
def test_case_0050_remains_refused_after_rat1():
"""Hazard pin: case 0050 must not admit after any RAT-1 wiring."""
import subprocess
import sys
subprocess.run(
[sys.executable, "-m", "evals.gsm8k_math.train_sample.v1.runner",
"--use-reader"],
cwd=_repo_root(),
capture_output=True,
)
report_path = (
_repo_root() / "evals" / "gsm8k_math" / "train_sample" / "v1" / "report.json"
)
report = json.loads(report_path.read_text())
case = next(
(c for c in report["per_case"] if c["case_id"].endswith("-0050")),
None,
)
assert case is not None, "case 0050 must exist in train_sample report"
assert case["verdict"] == "refused", (
f"case 0050 hazard pin violated: verdict={case['verdict']!r}"
)