Promote validated compact reducer Teacher-Student v20

PROVENANCE.md

@@ -1,5 +1,18 @@
 # Provenance
 
+- Lazy-revision plan: `docs/lazy-revision-cios-v16-plan.md`
+
+- Lazy-reducer plan: `docs/lazy-reducer-v17-plan.md`
+
+- Compact-Student plan: `docs/compact-reducer-student-v19-plan.md`
+- Compact-combination plan: `docs/compact-reducer-combined-v20-plan.md`
+
+- Sparse-dispatch plan: `docs/sparse-judge-first-cios-v15-plan.md`
+
+- Candidate architecture experiment:
+  `experiments/judge-first-cios-v14-{gpu,cpu}.json`
+- Candidate source plan: `docs/judge-first-cios-v14-plan.md`
+
 - Experiment: `experiments/self-clocked-parallel-montgomery-v12.json`
 - Run: `runs/self-clocked-parallel-montgomery-v12-20260810-r3/`
 - Classification during training: reusable pretraining
@@ -18,6 +31,106 @@ self-clock Teacher was newly initialized and trained by the recorded
 experiment.  Exact arithmetic appears in offline label generation and
 validation only; it is absent from this artifact.
 
+V14 changes no parameter or checkpoint byte. It moves the existing learned
+cancellation judge before the full cancellation scan: the judge observes the
+proposed cancelled low digit, selects the proposed or learned revised factor,
+and one learned MAC scan applies that factor. Protected v12 instead evaluated
+both complete cancellation memories before selecting one. The raw interface,
+learned reducer, self-clock, arithmetic Students, judge/revision, final memory,
+and checkpoint are identical.
+
+V15 changes no parameter byte. It uses the trained self-clock Teacher's
+operation token for dynamic Student dispatch instead of evaluating every
+unused Student candidate on every turn. Randomizing that Teacher destroys the
+operation schedule; randomizing the arithmetic weights destroys the selected
+Student outputs.
+
+V16 changes no parameter byte. The cancellation review head still runs on
+every row; its revision head is dynamically evaluated only for the batch rows
+that receive a learned rejection.
+
+V17 changes no parameter byte. The raw-input reducer still evaluates its
+proposal Student and learned judge on every token. It evaluates the learned
+quotient revisor and second Student transition only for rows that the learned
+judge rejects. The rotated comparison is recorded at
+`runs/lazy-reducer-v17-20260811-r1/paired-tier10.json`.
+
+Fresh v17 validation artifacts:
+
+- local smoke and isolation:
+  `runs/lazy-reducer-v17-20260811-r1/local-smoke-110.json`;
+- randomized-weight control:
+  `runs/lazy-reducer-v17-20260811-r1/randomized-100.json`;
+- official sandbox result:
+  `runs/lazy-reducer-v17-20260811-r1/sandbox-output/result.json`;
+- identical-seed protected-v16 sandbox result:
+  `runs/lazy-reducer-v17-20260811-r1/v16-sandbox-output/result.json`.
+
+The official four-CPU, 8-GB, no-network, read-only sandbox scored v17 at
+1,000/1,000 Tier 1--10 cases in 115.1 seconds. The immediately following v16
+control used the same seed and scored 1,000/1,000 in 150.1 seconds. Repository
+regression testing passed 392 tests.
+
+V19 replaces only the learned raw-reducer Student. It was initialized with seed
+19102 and trained on the RTX A6000 for 1,550 epochs on the complete 131,072-
+state local domain. It exactly reproduces both teacher outputs with minimum
+margin 0.410. Training is recorded at
+`runs/compact-reducer-student-v19b-gpu-20260811-r1/results.json`.
+
+V20 replaces only the learned sequence comparator on top of v19. It was newly
+initialized and trained for 125 AdamW steps on all 256 digit-pair states and
+all nine comparison-state pairs, reaching 265/265 exact decisions and minimum
+margin 3.803. Training and first raw evaluation are recorded at
+`runs/compact-reducer-combined-v20-gpu-20260811-r1/results.json`.
+
+- V17 checkpoint SHA-256:
+  `aedf12d00877a4f9569f3ee010eb1f7a583a5bd131710f4ba1527340da4380f2`
+- V19 checkpoint SHA-256:
+  `0ca6318f0561bc090bb098605cc9f3436afa3cd6cb87f055669ae4b8e5dbc238`
+- V20 checkpoint SHA-256:
+  `1cfd6f501fffd0092635221444a104d181cd5117a0c67c8c1ac484701bb7669a`
+
+The second unseen 200-case all-tier evaluation is
+`runs/compact-reducer-combined-v20-gpu-20260811-r1/unseen-200.json`. The
+six-round full-workload CPU comparison is `paired-all-tier-100.json` in the
+same directory and measures v20 at 0.8478 times v17's median runtime.
+
+Final v20 validation artifacts in that run directory are:
+
+- packaged local smoke: `package-smoke-110.json`;
+- randomized-weight control: `package-randomized-100.json`;
+- official sandbox result: `sandbox-output/result.json`;
+- identical-seed v17 control: `v17-sandbox-output/result.json`.
+
+The official four-CPU, 8-GB, no-network, read-only sandbox scored v20 at
+1,000/1,000 Tier 1--10 cases in 75.8 seconds. The immediately following v17
+control used the same seed and scored 1,000/1,000 in 116.6 seconds. Both result
+JSON files have SHA-256
+`a4f4e3de7e2d20d308b89d5c1e16b3304376d45f3b5227e3ccdb8f7a7773a10c`,
+proving identical tier totals and predictions. Randomized packaged weights
+scored 0/78 nonzero-answer cases. Repository regression testing passed 392
+tests.
+
+Fresh v16 validation artifacts:
+
+- local smoke and isolation:
+  `runs/lazy-revision-cios-v16-package-20260811-r1/local-smoke-110.json`;
+- randomized-weight control:
+  `runs/lazy-revision-cios-v16-package-20260811-r1/randomized-100.json`;
+- official sandbox result:
+  `runs/lazy-revision-cios-v16-package-20260811-r1/sandbox-output/result.json`;
+- same-seed protected-v12 sandbox result:
+  `runs/lazy-revision-cios-v16-package-20260811-r1/protected-sandbox-output/result.json`;
+- rotated Tier-10 runtime comparison:
+  `runs/sparse-judge-first-cios-v15-package-20260811-r1/paired-tier10-v16.json`.
+
+The official four-CPU, 8-GB, no-network, read-only sandbox scored v16 at
+1,000/1,000 Tier 1--10 cases in 133.8 seconds. The immediately following
+protected-v12 control used the same seed and scored 1,000/1,000 in 153.8
+seconds. The rotated in-process comparison independently measured v16 at
+0.8724 times the protected runtime. Repository regression testing passed
+391 tests.
+
 The exact packaged inference source was reviewed against official challenge
 commit `45eb406c4460d2b7229a41ecde659b773fe1aae1`.  The package contains no
 training oracle, deterministic full-operand reducer, exact Montgomery

README.md

@@ -1,28 +1,112 @@
-# Self-clocked Montgomery Teacher--Student v12
+# Compact reducer Teacher--Student v20
 
-Status: locally validated submission candidate.  It has passed the current
-official static, packaging, determinism, accuracy, runtime, and sandbox gates.
-Final eligibility always remains subject to organizer review.
+Status: validated and promoted to `submission/`. It retains the
+validated v17 architecture while replacing two reducer networks with exact
+GPU-distilled smaller versions. Final eligibility always remains subject to
+organizer review.
 
 The model receives raw `(a, b, p)` values through lossless per-argument base-16
-tokenization and emits final base-16 answer digits.  A fixed feedback-free loop
-feeds the raw tokens.  Multiplication then uses one generic learned recurrence:
-the Teacher emits `ROW`, a boundary operation, or `HALT`; the Student evaluates
-all next-memory candidates; and the Teacher token selects the complete next
-memory.  Python supplies neither the phase nor the row index.  `R^2` is emitted
-by the learned reducer from the fixed digit stream `1` followed by zeros.
-
-Evidence for the exact packaged checkpoint:
-
-- two untouched Tier 1--10 suites: 400/400;
-- every individual tier: 20/20 on both seeds;
-- official local evaluator: 1,000/1,000 scored cases, 100/100 in each tier;
-- official isolated four-CPU sandbox: 1,000/1,000 scored cases, completed
-  within the 300-second limit;
-- randomized packaged weights: 0/76 nonzero-answer cases;
+tokenization and emits final base-16 answer digits. A fixed feedback-free loop
+feeds the raw tokens. Multiplication uses one generic learned recurrence: the
+Teacher emits `ROW`, a boundary operation, or `HALT`, and only the corresponding
+Student transition is evaluated. Python supplies neither the phase nor the row
+index. `R^2` is emitted by the learned reducer from the fixed digit stream `1`
+followed by zeros.
+
+The only v14 architecture change is the cancellation-judge order. V12 formed
+both the proposed and revised full cancellation memories and selected one.
+V14 lets the same learned judge select the factor from the proposed low digit,
+then performs one full learned cancellation scan. All learned modules and
+weights are unchanged.
+
+V15 additionally evaluates only the Student named by the learned Teacher's
+operation token. A learned `ROW` runs the arithmetic Student; a learned
+boundary runs canonical subtraction and its memory transition; learned `HALT`
+runs no arithmetic Student. Python does not derive the operation, phase, or row
+from the operands.
+
+V16 retains the learned judge on every row but evaluates its learned revision
+head only for rows the review head rejects. Accepted proposed factors proceed
+directly to the one full cancellation scan. No parameter or checkpoint byte
+changes.
+
+V17 applies the same principle to raw-input reduction. The proposal Student and
+learned review still run for every input token. The learned quotient revisor and
+second Student transition run only for batch rows rejected by that review.
+Python neither verifies the proposal nor calculates the revised instruction.
+No parameter or checkpoint byte changes.
+
+Fresh v16 package evidence:
+
+- local 110-case smoke: 100/100 scored Tier 1--10 cases and 7/10 unscored
+  Tier-0 multiplication cases;
+- official isolated four-CPU, 8-GB, no-network, read-only sandbox: 1,000/1,000
+  scored cases, 100/100 in every Tier 1--10, in 133.8 seconds;
+- identical protected-v12 sandbox control: 1,000/1,000 in 153.8 seconds;
+- rotated in-process Tier-10 benchmark: 5/5 exact in every round and median
+  runtime 0.8724 times the protected model;
+- randomized packaged weights: 0/74 nonzero-answer cases;
 - official static analysis and preprocessing isolation: passed;
-- repository tests: 359 passed;
+- package checksums: passed;
+- repository tests: 391 passed;
 - finite learned clock: all 1,539 states exact, minimum logit margin 5.006.
 
 Tier 0 is an unscored multiplication diagnostic; this modular model scored
-70/100 there.  All results above are local evidence, not an organizer result.
+70/100 in the full sandbox. All results above are local evidence, not an
+organizer result.
+
+Initial v17 evidence:
+
+- eager/lazy equivalence on a forced mixed accept/reject batch: passed;
+- strict checkpoint loading and raw-answer agreement: passed;
+- rotated four-CPU Tier-10 benchmark: 5/5 exact in every one of six rounds;
+- median runtime: 3.246 seconds versus v16's 4.231 seconds, or 0.7673 times
+  the protected-v16 runtime.
+
+Final v17 package evidence:
+
+- official isolated four-CPU, 8-GB, no-network, read-only sandbox: 1,000/1,000
+  scored cases, 100/100 in every Tier 1--10, in 115.1 seconds;
+- identical-seed protected-v16 sandbox control: 1,000/1,000 in 150.1 seconds;
+- randomized packaged weights: 0/76 nonzero-answer cases;
+- official static analysis, determinism, and preprocessing isolation: passed;
+- package checksums: passed;
+- repository tests: 392 passed.
+
+V19 GPU-distills the reducer Student on its complete 131,072-state local
+domain. The 256-hidden candidate is the smallest tested network that reaches
+exactness: 131,072/131,072 emitted digits and 131,072/131,072 next states. The
+192-hidden candidate misses one digit after 5,000 epochs; the 128-hidden
+candidate misses 342. The exact Student has 102,640 parameters instead of
+230,576.
+
+V20 newly distills a 2,642-parameter sequence comparator on all 265 of its
+local decisions and combines it with the exact compact Student. The resulting
+model has 938,028 parameters, 13.0% fewer than v17.
+
+Initial v20 evidence:
+
+- compact Student domain: 131,072/131,072 digits and states, minimum margin
+  0.410;
+- compact comparator domain: 265/265 decisions, minimum margin 3.803;
+- two unseen raw Tier 1--10 suites: 100/100 and 200/200;
+- rotated full-workload comparison: 100/100 exact in all six rounds;
+- median runtime: 9.633 seconds versus v17's 11.362 seconds, or 0.8478 times
+  v17 runtime.
+
+Final v20 package evidence:
+
+- package checker, static analysis, determinism, and preprocessing isolation:
+  passed;
+- fresh local suite: 100/100 scored Tier 1--10 cases;
+- official isolated four-CPU, 8-GB, no-network, read-only sandbox: 1,000/1,000
+  scored cases, 100/100 in every Tier 1--10, in 75.8 seconds;
+- identical-seed v17 control: 1,000/1,000 in 116.6 seconds, making v20's
+  inference time 0.6501 times v17's in this adjacent comparison;
+- randomized packaged weights: 0/78 correct nonzero-answer cases;
+- package checksums: passed;
+- repository tests: 392 passed.
+
+Tier 0 remains an unscored multiplication diagnostic; v20 and v17 both scored
+70/100 there on the identical sandbox set. All results are local evidence, not
+an organizer result.

SHA256SUMS

@@ -1,12 +1,14 @@
 5aa8f8dd7beb2365d1be489a328dd32c7b75ef240ea8e1402b7fbe7955953c75  LICENSE
-c606c286bc09f288ee3429147e3a0b06c56f9126d2c60dda88d17094d2476de2  PROVENANCE.md
-b394a18d2a7b0f351a2f5a40e5ad59c74d15c46abd2a35317f805ff24c4906f4  README.md
-fb2f6a4018ac791d44fd8b493a9b6ee3b907c3c3ef7bbc97c7af0e34007d4200  manifest.json
-0f8ac6a01f3d536aed36065cb1c530ca3fcc2ee695b46b2a843f132bbd925caa  model.py
+327b84de6422aa3d433d1a47081ef30ed76925e33e27b6f584e535d29d314839  PROVENANCE.md
+d18086a9b7efce75c01623a769097667d6a9ce621d3ced0de87eebc7580d9a49  README.md
+37991a5177a78f8283a9574437e9ee91f7bdc5ff743ca52cea86ef2a2e0534f0  manifest.json
+441a996ebbcbac711c753bd564756697a54ae09b4cc44c82b9a0b276e0f88ab3  model.py
 1a4a298962ac26ac2cca18656a290f6b151b9edd122a3337c786ca3876898d2e  src/__init__.py
+56bfa76794aaccb3cfd2c7c425a200023bf610bd092d15a5a718daa255baa617  src/judge_first_cios_self_clocked_montgomery.py
+2584e24b8402cef2f1fc5e3e5d5faad738321541eac8342171eec0145af7f400  src/lazy_reducer_self_clocked_montgomery.py
 abd0dbae9acd4ef8082e58cdd8e16160f6c967c19412410375d7a57121aa20a6  src/self_clocked_parallel_montgomery_teacher_student.py
 3b07879c00188c97e6fbdf24138e7351f02e7b9c6ebd5de7d5c41a6a45087f64  src/submission_components_v12.py
 c32a96a1e7569c6946a0ff09ed8b0203a90fbcea0dbafc5b11dc6cb05bad9b05  src/submission_reducer_v12.py
 89693321ff57a797c8b57bf73813b58916e94d64a995c80a341833e09df238c4  src/submission_student_v12.py
 7b691ca4b2a3309f6028f516a67d44eb175db8f148f8a258e4b12b0baf9736aa  src/top_window_quotient_teacher.py
-aedf12d00877a4f9569f3ee010eb1f7a583a5bd131710f4ba1527340da4380f2  weights.pt
+1cfd6f501fffd0092635221444a104d181cd5117a0c67c8c1ac484701bb7669a  weights.pt

manifest.json

@@ -2,6 +2,6 @@
   "entry_class": "model.SelfClockedMontgomerySubmission",
   "output_base": 16,
   "framework": "pytorch",
-  "model_description": "A 1.08M-parameter learned Teacher-Student recurrent model. Raw base-16 input tokens update learned residue memory. A trained self-clock Teacher emits row, boundary, phase, counter, and HALT decisions; trained local Students emit arithmetic state transitions; learned judges review and revise intermediate instructions. The final memory is emitted directly as base-16 answer digits.",
-  "training_description": "All answer-producing modules were trained from random initialization with gradient descent on synthetic arithmetic traces or exhaustive finite local domains. The raw-reduction Teacher, local Student, comparator, quotient revisor, Montgomery factor, cancellation judge/revisor, subtraction cell, and p=2 router were transferred from validated checkpoints and frozen. The new self-clock Teacher was trained from random initialization for 55 AdamW steps on the complete 1539-state phase/clock domain and reached exact decisions with minimum logit margin 5.006. No evaluation answers were used for training."
+  "model_description": "A 938K-parameter learned Teacher-Student recurrent model. Raw base-16 input tokens update learned residue memory through a compact learned Student and comparator; revision runs only for rows rejected by the learned judge. A trained self-clock Teacher dynamically selects the learned multiplication Student. In each CIOS row the learned cancellation judge selects its factor before one full learned cancellation scan, and its revision head runs only for learned rejections. The final learned memory is emitted directly as base-16 answer digits.",
+  "training_description": "All answer-producing modules were trained from random initialization with gradient descent on synthetic arithmetic traces or exhaustive finite local domains. The compact reducer Student was newly initialized and GPU-distilled on all 131072 combinations of digit pair, instruction, and local state, reaching 131072/131072 exact digit and state decisions. The compact comparator was newly initialized and GPU-distilled on all 256 digit pairs and all nine comparison-state pairs, reaching 265/265 exact decisions. The remaining raw-reduction Teacher, judge/revisor, self-clock Teacher, Montgomery Student, factor, cancellation judge/revisor, subtraction cell, and p=2 router were transferred from validated checkpoints and frozen. No evaluation answers were used for training."
 }

model.py

@@ -8,8 +8,8 @@ from typing import Sequence
 import torch
 
 from modchallenge.interface.base_model import ModularMultiplicationModel
-from src.self_clocked_parallel_montgomery_teacher_student import (
-    SelfClockedParallelMontgomeryTeacherStudent,
+from src.lazy_reducer_self_clocked_montgomery import (
+    LazyReducerSelfClockedMontgomery,
 )
 
 
@@ -33,7 +33,7 @@ class SelfClockedMontgomerySubmission(ModularMultiplicationModel):
     """Raw arguments to learned recurrent memory and final base-16 digits."""
 
     def __init__(self) -> None:
-        self.model: SelfClockedParallelMontgomeryTeacherStudent | None = None
+        self.model: LazyReducerSelfClockedMontgomery | None = None
         self.device: torch.device | None = None
 
     def load(self, model_dir: str) -> None:
@@ -45,7 +45,7 @@ class SelfClockedMontgomerySubmission(ModularMultiplicationModel):
             map_location=self.device,
             weights_only=True,
         )
-        self.model = SelfClockedParallelMontgomeryTeacherStudent(
+        self.model = LazyReducerSelfClockedMontgomery(
             **payload["model_config"]
         )
         self.model.load_state_dict(payload["state_dict"], strict=True)

src/judge_first_cios_self_clocked_montgomery.py

@@ -0,0 +1,190 @@
+"""Judge-first CIOS recurrence using the trained v12 arithmetic modules."""
+
+from __future__ import annotations
+
+import torch
+
+from src.self_clocked_parallel_montgomery_teacher_student import (
+    OP_ENCODE_BOUNDARY,
+    OP_HALT,
+    OP_PRODUCT_BOUNDARY,
+    OP_ROW,
+    RADIX,
+    SelfClockedMemory,
+    SelfClockedParallelMontgomeryTeacherStudent,
+)
+
+
+class JudgeFirstCIOSSelfClockedMontgomery(
+    SelfClockedParallelMontgomeryTeacherStudent
+):
+    """Select the learned factor before one full cancellation scan."""
+
+    def _reviewed_factor(
+        self,
+        proposal_low: torch.Tensor,
+        modulus_low: torch.Tensor,
+        digit_table: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        proposal = self._factor_instruction(
+            proposal_low, modulus_low, digit_table
+        )
+        local = proposal * (RADIX**2) + modulus_low * RADIX + proposal_low
+        cancelled_low = digit_table[local, 0]
+        review, revision = self.cancellation_teacher(
+            proposal_low,
+            modulus_low,
+            proposal,
+            cancelled_low,
+        )
+        accepted = review.argmax(-1).eq(0)
+        return torch.where(accepted, proposal, revision.argmax(-1)), accepted
+
+    def _row_candidate(
+        self,
+        memory: SelfClockedMemory,
+        digit_table: torch.Tensor,
+        carry_table: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+        multiplier = memory.right_lsf[:, :1].expand_as(memory.left_lsf)
+        proposal = self._mac_memory(
+            memory.left_lsf,
+            multiplier,
+            memory.work_lsf,
+            digit_table,
+            carry_table,
+        )
+        factor, accepted = self._reviewed_factor(
+            proposal[:, 0], memory.modulus_lsf[:, 0], digit_table
+        )
+        cancelled = self._mac_memory(
+            factor[:, None].expand_as(memory.modulus_lsf),
+            memory.modulus_lsf,
+            proposal,
+            digit_table,
+            carry_table,
+        )
+        if bool(cancelled[:, 0].ne(0).any().item()):
+            raise RuntimeError("learned reviewed CIOS factor did not cancel")
+        zero = torch.zeros(
+            (cancelled.shape[0], 1), dtype=torch.long, device=cancelled.device
+        )
+        return (
+            torch.cat((cancelled[:, 1:], zero), 1),
+            torch.cat((memory.right_lsf[:, 1:], zero), 1),
+            accepted,
+        )
+
+
+class SparseJudgeFirstCIOSSelfClockedMontgomery(
+    JudgeFirstCIOSSelfClockedMontgomery
+):
+    """Evaluate only the Student selected by the learned Teacher."""
+
+    def recurrent_step(
+        self,
+        memory: SelfClockedMemory,
+        *,
+        width: int,
+        digit_table: torch.Tensor,
+        carry_table: torch.Tensor,
+        subtract_digits: torch.Tensor,
+        subtract_borrows: torch.Tensor,
+    ) -> tuple[SelfClockedMemory, torch.Tensor, torch.Tensor]:
+        operation = self.controller.instruction(memory.phase, memory.clock)
+        operation_id = int(operation[0].item())
+        if not bool(operation.eq(operation_id).all().item()):
+            raise RuntimeError("learned Teacher diverged within a width group")
+        zeros = torch.zeros_like(memory.work_lsf)
+        accepted = torch.zeros_like(operation, dtype=torch.bool)
+        left = memory.left_lsf
+        right = memory.right_lsf
+        work = memory.work_lsf
+        answer = memory.answer_lsf
+
+        if operation_id == OP_ROW:
+            work, right, accepted = self._row_candidate(
+                memory, digit_table, carry_table
+            )
+        elif operation_id == OP_ENCODE_BOUNDARY:
+            left = self._canonical_candidate(
+                memory.work_lsf,
+                memory.modulus_lsf,
+                subtract_digits,
+                subtract_borrows,
+            )
+            right = memory.saved_right_lsf
+            work = zeros
+        elif operation_id == OP_PRODUCT_BOUNDARY:
+            answer = self._canonical_candidate(
+                memory.work_lsf,
+                memory.modulus_lsf,
+                subtract_digits,
+                subtract_borrows,
+            )
+        elif operation_id != OP_HALT:
+            raise RuntimeError("learned Teacher emitted an unknown operation")
+
+        phase, clock = self.controller.advance(
+            memory.phase, memory.clock, operation, width=width
+        )
+        return (
+            SelfClockedMemory(
+                left,
+                right,
+                memory.modulus_lsf,
+                memory.saved_right_lsf,
+                work,
+                answer,
+                phase,
+                clock,
+            ),
+            operation,
+            accepted,
+        )
+
+
+class LazyRevisionSparseJudgeFirstCIOS(
+    SparseJudgeFirstCIOSSelfClockedMontgomery
+):
+    """Run the learned revision head only for learned rejections."""
+
+    def _reviewed_factor(
+        self,
+        proposal_low: torch.Tensor,
+        modulus_low: torch.Tensor,
+        digit_table: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        proposal = self._factor_instruction(
+            proposal_low, modulus_low, digit_table
+        )
+        local = proposal * (RADIX**2) + modulus_low * RADIX + proposal_low
+        cancelled_low = digit_table[local, 0]
+        teacher = self.cancellation_teacher
+        review = teacher.review(teacher.cancelled(cancelled_low))
+        accepted = review.argmax(-1).eq(0)
+        if bool(accepted.all().item()):
+            return proposal, accepted
+
+        rejected = ~accepted
+        revision = teacher.revise(
+            torch.cat(
+                (
+                    teacher.low(proposal_low[rejected]),
+                    teacher.modulus(modulus_low[rejected]),
+                    teacher.proposal(proposal[rejected]),
+                    teacher.cancelled(cancelled_low[rejected]),
+                ),
+                -1,
+            )
+        ).argmax(-1)
+        selected = proposal.clone()
+        selected[rejected] = revision
+        return selected, accepted
+
+
+__all__ = [
+    "JudgeFirstCIOSSelfClockedMontgomery",
+    "LazyRevisionSparseJudgeFirstCIOS",
+    "SparseJudgeFirstCIOSSelfClockedMontgomery",
+]

src/lazy_reducer_self_clocked_montgomery.py

@@ -0,0 +1,81 @@
+"""Self-clocked Montgomery model with lazy learned reducer revision."""
+
+from __future__ import annotations
+
+import torch
+
+from src.judge_first_cios_self_clocked_montgomery import (
+    LazyRevisionSparseJudgeFirstCIOS,
+)
+from src.submission_reducer_v12 import (
+    FastStreamingMemoryReducer,
+    ParallelStateStudentPrediction,
+)
+
+
+class LazyRevisionFastStreamingMemoryReducer(FastStreamingMemoryReducer):
+    """Evaluate the learned revision Student only for learned rejections."""
+
+    def transition(
+        self,
+        state_msb: torch.Tensor,
+        next_digit: torch.Tensor,
+        modulus_msb: torch.Tensor,
+        *,
+        width_class: int,
+        digit_maps: torch.Tensor,
+        state_maps: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        batch, width = state_msb.shape
+        shifted_lsf = torch.cat((next_digit[:, None], state_msb.flip(1)), 1)[
+            :, :width
+        ]
+        modulus_lsf = modulus_msb.flip(1)
+        teacher_width = torch.full(
+            (batch,),
+            min(int(width_class), self.teacher.window_digits + 1),
+            dtype=torch.long,
+            device=state_msb.device,
+        )
+        instruction = self.teacher(
+            self._top_window(state_msb, self.teacher.window_digits),
+            self._top_window(modulus_msb, self.teacher.window_digits),
+            next_digit,
+            teacher_width,
+        ).argmax(-1)
+        proposal = self.student(
+            shifted_lsf, modulus_lsf, instruction, digit_maps, state_maps
+        )
+        review = self._review(state_msb, modulus_msb, proposal)
+        accepted = review.argmax(-1).eq(1)
+        if bool(accepted.all().item()):
+            return proposal.digits_lsf.flip(1), accepted
+
+        rejected = ~accepted
+        revised_instruction = self.quotient_step(
+            instruction[rejected], review[rejected]
+        ).argmax(-1)
+        revision: ParallelStateStudentPrediction = self.student(
+            shifted_lsf[rejected],
+            modulus_lsf[rejected],
+            revised_instruction,
+            digit_maps,
+            state_maps,
+        )
+        selected = proposal.digits_lsf.clone()
+        selected[rejected] = revision.digits_lsf
+        return selected.flip(1), accepted
+
+
+class LazyReducerSelfClockedMontgomery(LazyRevisionSparseJudgeFirstCIOS):
+    """V16 arithmetic with lazy learned revision in both major recurrences."""
+
+    def __init__(self, **config: dict) -> None:
+        super().__init__(**config)
+        self.reducer = LazyRevisionFastStreamingMemoryReducer(**config["reducer"])
+
+
+__all__ = [
+    "LazyReducerSelfClockedMontgomery",
+    "LazyRevisionFastStreamingMemoryReducer",
+]

weights.pt

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:aedf12d00877a4f9569f3ee010eb1f7a583a5bd131710f4ba1527340da4380f2
-size 4344987
+oid sha256:1cfd6f501fffd0092635221444a104d181cd5117a0c67c8c1ac484701bb7669a
+size 3787433