From ba57b98b3e76b7f557bef6faa82a9d75d49af9e5 Mon Sep 17 00:00:00 2001
From: Ali Romman <226877337+aliromman@users.noreply.github.com>
Date: Fri, 23 Oct 2026 14:56:48 -0500
Subject: [PATCH 1/2] Reduce actual QQ16 Context construction to quadratic
 source scans

---
 research/qq16-linear-radix-context/PROOF.md   | 178 ++++++++
 research/qq16-linear-radix-context/README.md  |  64 +++
 .../qq16-linear-radix-context/RESULT.json     | 379 ++++++++++++++++++
 .../qq16-linear-radix-context/SOURCES.json    |  49 +++
 research/qq16-linear-radix-context/TASK.json  |  90 +++++
 .../qq16-linear-radix-context/VERIFY.json     |  39 ++
 .../qq16-linear-radix-context/constructor.py  |  55 +++
 .../vendor/installation_source.py             | 238 +++++++++++
 research/qq16-linear-radix-context/verify.py  | 133 ++++++
 9 files changed, 1225 insertions(+)
 create mode 100644 research/qq16-linear-radix-context/PROOF.md
 create mode 100644 research/qq16-linear-radix-context/README.md
 create mode 100644 research/qq16-linear-radix-context/RESULT.json
 create mode 100644 research/qq16-linear-radix-context/SOURCES.json
 create mode 100644 research/qq16-linear-radix-context/TASK.json
 create mode 100644 research/qq16-linear-radix-context/VERIFY.json
 create mode 100644 research/qq16-linear-radix-context/constructor.py
 create mode 100644 research/qq16-linear-radix-context/vendor/installation_source.py
 create mode 100644 research/qq16-linear-radix-context/verify.py

diff --git a/research/qq16-linear-radix-context/PROOF.md b/research/qq16-linear-radix-context/PROOF.md
new file mode 100644
index 0000000000..bf3ed6adeb
--- /dev/null
+++ b/research/qq16-linear-radix-context/PROOF.md
@@ -0,0 +1,178 @@
+# Linear radix scans in the actual Context constructor
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+
+## Result and credited premises
+
+For each fixed compiled radix q>=2 and dimension d>=1, let M=q^w with w>=1.
+Let B=bit_length(M)+1 be the retained Word extent, including its zero high
+margin. The new constructor returns the same genuine source Context, cap
+q^(w-1), and high Count H=q^((w-1)d^2). It executes through the unchanged
+Machine.new_context and save_count bodies with one explicit Context factory.
+It preserves the source Ring/raw aliases, fixed Tape views, numerical inputs,
+other borrowed records and canonical heads.
+
+The numerical and record source-action count is O(w^2) for fixed q,d. The
+literal and already-shared Context have an Omega(w^3) general-division term.
+The new constructor uses one temporary record-tape lease and four live
+numerical Words, including the supplied modulus and retained ring.one. The
+literal and shared fixtures require two leases and nine numerical Words.
+These are local counts in the named source model, not a complete supplier
+or frontend tariff. Extra caller-owned words remain additional live storage.
+
+The count formula and source classes are retained. ToikY's
+[PR #4025](https://github.com/CrocSwap/integer-mult-bounds/pull/4025) supplies
+shared high-power traversal; Chris R's
+[PR #4062](https://github.com/CrocSwap/integer-mult-bounds/pull/4062) already
+applies it to Context construction. Ali Romman's
+[PR #5025](https://github.com/CrocSwap/integer-mult-bounds/pull/5025) supplies
+a unary radix cache at a different caller. No new claim is made for sharing
+or caching radix iterations. Fixed-radix long division is classical and is
+already used by Natural.divide_small in the retained source. This work binds
+that operation to fixed-width Words and fuses the actual Context producer.
+Mihir Srivastava's [PR #5363](https://github.com/CrocSwap/integer-mult-bounds/pull/5363)
+supplies the installation proof and source extraction fixture.
+
+## Quotient and constructor invariants
+
+The quotient kernel moves to the most significant bit of an owned B-bit
+Word. It scans left, with finite remainder r initially zero. For each input
+bit b, replace r by 2r+b. Write quotient bit one and subtract q when r>=q;
+otherwise write zero. Before each iteration 0<=r<q, and before subtraction
+0<=2r+b<2q. Thus the control state is finite for compiled q. No runtime
+Word, exponent or cardinality is decoded into an unbounded host integer.
+The unread lower bits are not changed. Standard prefix induction proves
+that the final Word is floor(x/q) and the returned state is x mod q. The
+RIGHT marker and fixed leading zero margin remain in place. The head returns
+to one. The kernel also works when x<q and for words without a high margin;
+the Context caller uses the stronger retained margin contract.
+
+Copy the supplied modulus to one owned Word, and create Count() with value
+one on one leased record tape. Compare the power Word with ring.one. At each
+iteration divide that owned Word by q in place and require zero remainder.
+At the first iteration, copy the quotient into the persistent cap Word.
+At every later iteration, execute d^2 unchanged Count.multiply_small(q)
+operations. Stop when the power equals one, then erase it.
+
+For M=q^w there are exactly w iterations. The first quotient is q^(w-1).
+There are exactly m=d^2(w-1) Count multiplications, so the result is H=q^m.
+This is the already-credited shared multiplication order. The first quotient
+also supplies cap, and the same traversal validates M. No second validation,
+separate cap division or unary guide is needed. All source Context fields
+are installed in their original order and with their original shared aliases.
+The returned Count is then installed by the unchanged source save_count.
+
+On a non-power modulus, a nonzero remainder rejects. The owned count is
+closed and Arena.rollback restores the recorded set of borrowed Words.
+The compiled-vocabulary check occurs before allocation. Valid-call numerical
+and record costs below do not claim a complete rejecting-path tariff.
+
+## Exact numerical bill
+
+Count each primitive read, write and unit move as one source action. A rewind
+from offset h costs 2h+3. The quotient kernel costs exactly 5B+7: its initial
+msb operation costs 2B+5, and its descending quotient scan costs 3B+2.
+The current bit is read once per iteration and retained as a finite symbol.
+
+For the authenticated fixed-width Word methods, with heads at one:
+
+```text
+Arena.zero       9B+12
+Arena.copy      18B+22
+Arena.free       5B+8
+Unsigned.compare (distinct Words) 9B+14
+Ring construction                22B+41
+```
+
+These follow by counting the literal loops. Zero includes template reads,
+blank-cell checks, delimiter installation and both rewinds. Copy includes
+zero initialization and both payload rewinds. Free includes the final erased
+RIGHT cell. Ring includes one literal, comparison, high-margin inspection
+and head return. Metadata allocation and pool selection are separate below.
+
+Context production uses two copies, one free, w quotient scans and w+2
+comparisons. Hence its numerical action count is exactly
+
+```text
+C_word = (14w+59)B + 21w+80.
+```
+
+The final comparison is deliberately included even though the while condition
+has already stopped. The source interpreter and verifier execute it.
+
+## Exact record and complete constructor bill
+
+Put n_j=bit_length(q^j), m=d^2(w-1), and N=n_m. Count() costs 22 tape actions;
+the scratch allocator's blank-read adds one. One multiplication from length
+n_j to n_(j+1) costs
+
+```text
+6 n_j + 4(n_(j+1)-n_j) + 5.
+```
+
+The four-term part includes new high bits and the longer return scan. Thus
+
+```text
+C_record = 23 + 6 sum_(j=0)^(m-1) n_j + 4(N-1) + 5m.
+```
+
+An empty sum gives 23 when w=1. The proof needs no floating logarithm.
+The verifier computes the integer lengths independently for its finite cases.
+The bound C_record <= 23+6mN+4(N-1)+5m is uniform.
+
+Let D be the old dense highs body length. The unchanged installation uses
+n=N+1 cells including RIGHT and costs 15n+5D+24 actions. This is the sum
+of the separate read/write/move bill proved in PR5363. It includes clearing
+the old destination, copying, rewinds, source cleanup and its idempotent
+second close. The actual parked recursive caller has D=0; standalone dirty
+replacement cases remain checked with D>0.
+
+The complete executed new_context numerical/record bill is therefore
+
+```text
+22B+41 + C_word + C_record + 15(N+1)+5D+24.
+```
+
+Input construction and final disposal of the returned Context are outside
+this constructor interval. The verifier separately executes disposal and
+checks that all returned owned state is released. No leaked temporary is
+counted as output. Pool/control bookkeeping and physical metadata compilation
+are not included in this source-action bill.
+
+## Strict improvement over already-shared traversal
+
+The literal source performs ((d^2+1)w+1) general Word divisions. The shared
+predecessor performs 2w+1: one validation traversal, one count traversal,
+and the cap division. Each general divmod scans all B numerator bits. Every
+iteration calls shift_add_bit, which scans all B remainder bits, even when
+those bits are zero. Thus that component alone is Omega(w B^2).
+
+For fixed compiled q and d, B=Theta(w), m=O(w), and N=O(w). The new exact
+formula is O(wB+mN+B+N+D), hence O(w^2+D). The already-shared general-division
+term is Omega(w^3). Both constructors retain the same m Count multiplications.
+This is an asymptotic source-action comparison for fixed q,d, not a uniform
+finite-state-size bound as q varies or a measured wall-clock guarantee.
+
+At q=5,w=8,d=4,D=0, the literal, shared and fused complete constructors use
+2614926, 407496 and 96660 source actions respectively. All produce the same
+261-bit Count and preserve the same borrowed state. The new construction
+saves 76.28 percent against the shared predecessor on this fixture.
+
+## Storage, source boundary and limitations
+
+On Context entry, ring.modulus and ring.one are live. The only additional
+numerical Words are the owned power and cap. Thus four suffice in the fixture;
+with R other live caller Words the peak is R+4. A zero template is separate
+backing. Count() needs one record tape, which save_count returns empty. Its
+maximum body is N+1 cells plus the LEFT marker. The installed highs output
+also owns its complete N+1-cell body. Erased backing is retained capacity,
+not a free resource. No extra unary guide or giant quotient table is supplied.
+
+Source files come from the unchanged PR2753/2809 nested archive and exact
+PR4025/4062 and PR5363 pins. The full loader, selected codebook, physical
+pool/handle controller, arbitrary caller root closure, parent parking,
+complete F(K), native/stock/precision and outer recovery are not implemented
+or verified here. The source factory binding is explicit and local to this
+package. No frozen runtime or selected frontier is changed. The complete
+kappa calculation is unchanged. Independent human and proof-kernel acceptance
+remain open.
diff --git a/research/qq16-linear-radix-context/README.md b/research/qq16-linear-radix-context/README.md
new file mode 100644
index 0000000000..d3c3e0b050
--- /dev/null
+++ b/research/qq16-linear-radix-context/README.md
@@ -0,0 +1,64 @@
+# Quadratic-scan QQ16 Context construction
+
+For fixed compiled radix q and dimension d, this package reduces the actual
+Context constructor's numerical/record source-action count from a cubic
+Word-division term to a quadratic bound in the radix exponent w. It uses one
+fixed-q quotient scan per radix digit, reuses the first quotient as cap, and
+retains the credited shared Count multiplications. Runtime w is never decoded.
+
+At q=5,w=8,d=4, the complete new_context/save_count interval uses 96660 actions,
+versus 407496 for the already-shared predecessor and 2614926 for the literal
+source. The local peaks fall from two record leases and nine numerical Words
+to one lease and four Words, including modulus and ring.one.
+
+[PROOF.md](PROOF.md) gives the exact bills, all-size proof, source boundary
+and full predecessor credit. [constructor.py](constructor.py) is the new
+implementation. [RESULT.json](RESULT.json) records 1512 complete quotient
+cases, 21 actual constructor runs in seven matched triples, and four
+non-power rejection/rollback controls. The comparisons include dimension64
+at w=1, dirty highs replacement, canonical heads and exact alias checks.
+
+```sh
+python3.12 -B scripts/research_package.py --package research/qq16-linear-radix-context
+```
+
+Both registered isolated, warning-strict normal and optimized modes print
+`PASS_LINEAR_RADIX_CONTEXT`. The standard library suffices. Source hashes
+and the complete typed receipt are checked. No timing benchmark is claimed.
+
+The complete kappa calculation is unchanged. The count formula, loop sharing
+and fixed-radix long division are credited predecessor methods; the new part
+is the fixed-Word scan and fused actual constructor with its complete local
+invoice. Compiled q and d belong to fixed control. The bound does not certify
+uniform control size as q grows. Pool/metadata control, the full loader,
+source codebook, physical root closure, complete frontend F(K), parent parking,
+stock/precision and supplier admission remain separate. Lean, Docker, selected
+cold replay and full-history validation were not run.
+
+## Open next questions
+
+Compose this constructor with the finite-handle restore/adopt implementation
+and actual parked caller roots. Start from the literal new_context and
+restore_context replacement path, retaining all source aliases and record
+slots. The numerical/record improvement does not give a complete controller
+bill or resolve arbitrary live caller references.
+
+## Credit and coordination
+
+Base 7c472563474e60185e6ca101a17622133d047e56, priority 7. Current main, the live
+Context handoff, all-state numerical-producer PR search and relevant main notes
+were checked. Arbitrary historical diffs and unpublished work remain outside
+coverage. [SOURCES.json](SOURCES.json) pins all inputs. The byte-exact fixture
+in vendor/ is consumed from pending PR5363; its status is explicit.
+
+ToikY supplied shared traversal; Chris R/Clear1nsight applied it to Context.
+Mihir Srivastava supplied the high-count installation audit and source loader.
+Jose Manuel/jmbarrancoml and David Arias supplied the retained physical caller
+and cardinality source. JoyboyBrian supplied the constructor handoff; Tekalign,
+ywz65 and the retained control/record lineage keep their attribution. The
+retained Natural.divide_small is the algorithmic precedent for fixed-q division.
+See PROOF.md for full PR links. Original notices are unchanged.
+
+New work: Ali Romman with substantial OpenAI Codex assistance in derivation,
+implementation, review and verification. Apache-2.0. No independent human or
+proof-kernel acceptance is claimed.
diff --git a/research/qq16-linear-radix-context/RESULT.json b/research/qq16-linear-radix-context/RESULT.json
new file mode 100644
index 0000000000..7b204bc788
--- /dev/null
+++ b/research/qq16-linear-radix-context/RESULT.json
@@ -0,0 +1,379 @@
+{
+  "constructor_comparisons": [
+    [
+      {
+        "B": 3,
+        "actions": 3504,
+        "count_bits": 1,
+        "d": 1,
+        "dirty": 0,
+        "general_divisions": 3,
+        "mode": "literal",
+        "numerical_peak": 9,
+        "production": {
+          "record": 66,
+          "word": 3277
+        },
+        "q": 2,
+        "record_peak": 2,
+        "w": 1
+      },
+      {
+        "B": 3,
+        "actions": 3504,
+        "count_bits": 1,
+        "d": 1,
+        "dirty": 0,
+        "general_divisions": 3,
+        "mode": "shared",
+        "numerical_peak": 9,
+        "production": {
+          "record": 66,
+          "word": 3277
+        },
+        "q": 2,
+        "record_peak": 2,
+        "w": 1
+      },
+      {
+        "B": 3,
+        "actions": 504,
+        "count_bits": 1,
+        "d": 1,
+        "dirty": 0,
+        "general_divisions": 0,
+        "mode": "fused",
+        "numerical_peak": 4,
+        "production": {
+          "record": 23,
+          "word": 320
+        },
+        "q": 2,
+        "record_peak": 1,
+        "w": 1
+      }
+    ],
+    [
+      {
+        "B": 5,
+        "actions": 22512,
+        "count_bits": 7,
+        "d": 2,
+        "dirty": 0,
+        "general_divisions": 11,
+        "mode": "literal",
+        "numerical_peak": 9,
+        "production": {
+          "record": 182,
+          "word": 22035
+        },
+        "q": 3,
+        "record_peak": 2,
+        "w": 2
+      },
+      {
+        "B": 5,
+        "actions": 10446,
+        "count_bits": 7,
+        "d": 2,
+        "dirty": 0,
+        "general_divisions": 5,
+        "mode": "shared",
+        "numerical_peak": 9,
+        "production": {
+          "record": 182,
+          "word": 9969
+        },
+        "q": 3,
+        "record_peak": 2,
+        "w": 2
+      },
+      {
+        "B": 5,
+        "actions": 991,
+        "count_bits": 7,
+        "d": 2,
+        "dirty": 0,
+        "general_divisions": 0,
+        "mode": "fused",
+        "numerical_peak": 4,
+        "production": {
+          "record": 139,
+          "word": 557
+        },
+        "q": 3,
+        "record_peak": 1,
+        "w": 2
+      }
+    ],
+    [
+      {
+        "B": 8,
+        "actions": 63493,
+        "count_bits": 19,
+        "d": 2,
+        "dirty": 7,
+        "general_divisions": 16,
+        "mode": "literal",
+        "numerical_peak": 9,
+        "production": {
+          "record": 592,
+          "word": 62325
+        },
+        "q": 5,
+        "record_peak": 2,
+        "w": 3
+      },
+      {
+        "B": 8,
+        "actions": 28486,
+        "count_bits": 19,
+        "d": 2,
+        "dirty": 7,
+        "general_divisions": 7,
+        "mode": "shared",
+        "numerical_peak": 9,
+        "production": {
+          "record": 592,
+          "word": 27318
+        },
+        "q": 5,
+        "record_peak": 2,
+        "w": 3
+      },
+      {
+        "B": 8,
+        "actions": 2076,
+        "count_bits": 19,
+        "d": 2,
+        "dirty": 7,
+        "general_divisions": 0,
+        "mode": "fused",
+        "numerical_peak": 4,
+        "production": {
+          "record": 549,
+          "word": 951
+        },
+        "q": 5,
+        "record_peak": 1,
+        "w": 3
+      }
+    ],
+    [
+      {
+        "B": 8,
+        "actions": 282952,
+        "count_bits": 77,
+        "d": 4,
+        "dirty": 31,
+        "general_divisions": 69,
+        "mode": "literal",
+        "numerical_peak": 9,
+        "production": {
+          "record": 11482,
+          "word": 269904
+        },
+        "q": 3,
+        "record_peak": 2,
+        "w": 4
+      },
+      {
+        "B": 8,
+        "actions": 48532,
+        "count_bits": 77,
+        "d": 4,
+        "dirty": 31,
+        "general_divisions": 9,
+        "mode": "shared",
+        "numerical_peak": 9,
+        "production": {
+          "record": 11482,
+          "word": 35484
+        },
+        "q": 3,
+        "record_peak": 2,
+        "w": 4
+      },
+      {
+        "B": 8,
+        "actions": 14089,
+        "count_bits": 77,
+        "d": 4,
+        "dirty": 31,
+        "general_divisions": 0,
+        "mode": "fused",
+        "numerical_peak": 4,
+        "production": {
+          "record": 11439,
+          "word": 1084
+        },
+        "q": 3,
+        "record_peak": 1,
+        "w": 4
+      }
+    ],
+    [
+      {
+        "B": 20,
+        "actions": 2614926,
+        "count_bits": 261,
+        "d": 4,
+        "dirty": 0,
+        "general_divisions": 137,
+        "mode": "literal",
+        "numerical_peak": 9,
+        "production": {
+          "record": 88600,
+          "word": 2521891
+        },
+        "q": 5,
+        "record_peak": 2,
+        "w": 8
+      },
+      {
+        "B": 20,
+        "actions": 407496,
+        "count_bits": 261,
+        "d": 4,
+        "dirty": 0,
+        "general_divisions": 17,
+        "mode": "shared",
+        "numerical_peak": 9,
+        "production": {
+          "record": 88600,
+          "word": 314461
+        },
+        "q": 5,
+        "record_peak": 2,
+        "w": 8
+      },
+      {
+        "B": 20,
+        "actions": 96660,
+        "count_bits": 261,
+        "d": 4,
+        "dirty": 0,
+        "general_divisions": 0,
+        "mode": "fused",
+        "numerical_peak": 4,
+        "production": {
+          "record": 88557,
+          "word": 3668
+        },
+        "q": 5,
+        "record_peak": 1,
+        "w": 8
+      }
+    ],
+    [
+      {
+        "B": 5,
+        "actions": 285233,
+        "count_bits": 102,
+        "d": 8,
+        "dirty": 0,
+        "general_divisions": 131,
+        "mode": "literal",
+        "numerical_peak": 9,
+        "production": {
+          "record": 20158,
+          "word": 263355
+        },
+        "q": 3,
+        "record_peak": 2,
+        "w": 2
+      },
+      {
+        "B": 5,
+        "actions": 31847,
+        "count_bits": 102,
+        "d": 8,
+        "dirty": 0,
+        "general_divisions": 5,
+        "mode": "shared",
+        "numerical_peak": 9,
+        "production": {
+          "record": 20158,
+          "word": 9969
+        },
+        "q": 3,
+        "record_peak": 2,
+        "w": 2
+      },
+      {
+        "B": 5,
+        "actions": 22392,
+        "count_bits": 102,
+        "d": 8,
+        "dirty": 0,
+        "general_divisions": 0,
+        "mode": "fused",
+        "numerical_peak": 4,
+        "production": {
+          "record": 20115,
+          "word": 557
+        },
+        "q": 3,
+        "record_peak": 1,
+        "w": 2
+      }
+    ],
+    [
+      {
+        "B": 3,
+        "actions": 4811034,
+        "count_bits": 1,
+        "d": 64,
+        "dirty": 0,
+        "general_divisions": 4098,
+        "mode": "literal",
+        "numerical_peak": 9,
+        "production": {
+          "record": 66,
+          "word": 4810807
+        },
+        "q": 3,
+        "record_peak": 2,
+        "w": 1
+      },
+      {
+        "B": 3,
+        "actions": 3504,
+        "count_bits": 1,
+        "d": 64,
+        "dirty": 0,
+        "general_divisions": 3,
+        "mode": "shared",
+        "numerical_peak": 9,
+        "production": {
+          "record": 66,
+          "word": 3277
+        },
+        "q": 3,
+        "record_peak": 2,
+        "w": 1
+      },
+      {
+        "B": 3,
+        "actions": 504,
+        "count_bits": 1,
+        "d": 64,
+        "dirty": 0,
+        "general_divisions": 0,
+        "mode": "fused",
+        "numerical_peak": 4,
+        "production": {
+          "record": 23,
+          "word": 320
+        },
+        "q": 3,
+        "record_peak": 1,
+        "w": 1
+      }
+    ]
+  ],
+  "constructor_sha256": "9847f6d4fc0b95780394e9c486411247919be9878561dc55edce6dc5a439487f",
+  "quotient_cases": 1512,
+  "rejection_controls": 4,
+  "status": "PASS_LINEAR_RADIX_CONTEXT"
+}
diff --git a/research/qq16-linear-radix-context/SOURCES.json b/research/qq16-linear-radix-context/SOURCES.json
new file mode 100644
index 0000000000..b65b2640f1
--- /dev/null
+++ b/research/qq16-linear-radix-context/SOURCES.json
@@ -0,0 +1,49 @@
+{
+  "schema_version": 1,
+  "base_commit": "7c472563474e60185e6ca101a17622133d047e56",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395",
+      "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72"
+    },
+    {
+      "path": "research/physical-gaussian-leaf/inputs/pr3087.tar",
+      "usage": "input",
+      "git_blob": "6daedf70a927fa1359caec68d56fc0cbdaeb54dd",
+      "sha256": "d7e9c04a5e6d3f76158555d84080786c7cd8028ca31a61c9399de2b2c67bfd53"
+    },
+    {
+      "path": "research/r437-preparation-composition/PROOF.md",
+      "usage": "input",
+      "git_blob": "7dff5622034394009f908a659f20aa511e6becc2",
+      "sha256": "21c5b5a914a5417a385c41b800934c0b2e155ffef89681a6166465393f1cf7ea"
+    },
+    {
+      "path": "research/r437-preparation-composition/README.md",
+      "usage": "input",
+      "git_blob": "ee2d04215e35646a1c013c39e8840744aeb0ef8c",
+      "sha256": "413362271e8c3ad44aba1fcc751dc683fafa4c7ea694d9bcc05325a37f25cd20"
+    },
+    {
+      "path": "research/r437-preparation-composition/predecessor4025/verify.py",
+      "usage": "input",
+      "git_blob": "614e57282c0edfe39f1afe45d140cf338210e62a",
+      "sha256": "b2c72707bebb9ecdba2b89675830439393e6e13c76f68dad20d42d6ef70e539a"
+    },
+    {
+      "path": "research/qq16-high-count-installation/verify.py",
+      "usage": "provenance",
+      "pin": "head:5ac02c05ad29f4b136cab8fb787985a1ea64de80:research/qq16-high-count-installation/verify.py",
+      "git_blob": "6a661a1062409f527baaff94ff68f5677881e3cc",
+      "sha256": "7ca1094ad0a3d6d33c1c51f651c87d1ce10bc2f5aee03e6bae2f93aea7bb325f"
+    }
+  ]
+}
diff --git a/research/qq16-linear-radix-context/TASK.json b/research/qq16-linear-radix-context/TASK.json
new file mode 100644
index 0000000000..0798bdf526
--- /dev/null
+++ b/research/qq16-linear-radix-context/TASK.json
@@ -0,0 +1,90 @@
+{
+  "schema_version": 1,
+  "task_id": "joint-query-controller",
+  "priority_revision": 7,
+  "base_commit": "7c472563474e60185e6ca101a17622133d047e56",
+  "original_card": {
+    "id": "joint-query-controller",
+    "question": "Can the installed QQ16 caller win a complete matched protocol bill, or can a changed demand eliminate actual paid work?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "research/qq16-caller-install/README.md"
+    ],
+    "methods": [
+      "Derive the matched whole-caller physical bill for installed and baseline protocols.",
+      "Change the actual demanded observations and prove a cheaper legal producer/consumer contract."
+    ],
+    "acceptance_gate": "Name the changed premise of the fixed F0/B1 observation obstruction. Show exactly which query is recovered, legal native reads and restoration, and a full favorable budget including cover maps, helpers and endpoints. Local inverse identities alone do not close the global controller. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read #4166 COST.md and ADMISSION.json. An actual caller connection is now proposed. Its native-component profile loses; parent park/restore versus external-call costs remain unresolved. Retain the producer and recovery lineage rather than rebuild it.",
+      "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately."
+    },
+    "first_experiment": "At the actual installed cut, compare matched complete parent park/restore and external input/return protocols at the same bank/packet geometry, including every later root call and service cost. Alternatively pin both bridge observations and derive a genuinely smaller source-compatible demand. Stop if the complete necessary inequality fails or an essential cost is unknown; no larger decoder scan from a local tape-action saving.",
+    "bottleneck_link": "The native local words exist; retained query information and its physical access are the missing link to a composed recursive interface.",
+    "allowed_variations": [
+      "One paid query, one changed first pair, or one precisely specified affine helper state.",
+      "A counterexample or lower bound for that exact proposed repair.",
+      "One unresolved obligation of a newer local decoder, with exact source heads and a distinct claim/domain."
+    ],
+    "scope_change_triggers": [
+      "Retaining the fixed first pair and ordinary schedule while allowing only homogeneous selected-only control, already excluded by the witness.",
+      "Treating cover-map counts as zero-cost physical address operations.",
+      "Recreating the pending complete local decoder or early-record/output-bank coalescing already under investigation without a distinct audit or changed premise.",
+      "Treating a completed-output defect inequality as a producer-interior, dirty-range or physical-cost certificate.",
+      "Recreating completed-output recovery or caller wiring already supplied by #4166 without new independent coverage.",
+      "Dropping retained later root calls or claiming native-profile dominance from the isolated publication saving."
+    ],
+    "overlap_terms": [
+      "QQ16",
+      "joint-query",
+      "changing-chart controller",
+      "selected observation",
+      "1969",
+      "2540",
+      "early record",
+      "output-bank retention",
+      "complete native decoder",
+      "2965",
+      "producer defect",
+      "dirty-helper range",
+      "F17 consumer",
+      "4166",
+      "qq16-caller-install"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4166: author-checked installed producer/service/return/bridge connection; native-component comparison loses.",
+        "evidence": "research/qq16-caller-install/README.md",
+        "remaining": "Complete matched physical protocol bill, or changed source-compatible demand/circuit; no affordable supplier yet.",
+        "status": "author-checked",
+        "source_commit": "0b082d22a0e9a442d264ab0633e35ef26c790630",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      }
+    ]
+  },
+  "scope_status": "refined",
+  "actual_scope": "Fuse the actual QQ16 Context numerical producer with fixed-radix linear word division, retained shared count multiplication and direct cap reuse; execute new_context/save_count and price every numerical and record action.",
+  "scope_change_reason": "PR5363 leaves numerical production open. PR4025/4062 already share the count traversal, so that optimization is credited and used as a separate comparison. The new quotient kernel and fused constructor avoid general word division.",
+  "bottleneck_link": "The already-shared Context still has a cubic-in-width general-division cost at fixed compiled q and d. The new constructor reduces the source-action count to quadratic, while reducing scratch and numerical peaks.",
+  "budget_minutes": 60,
+  "stop_rule": "One complete numerical/record constructor boundary with exact costs; no full frontend/control or native supplier claim.",
+  "outcome": "completed",
+  "evidence": "PROOF.md, constructor.py, verify.py, RESULT.json",
+  "author": "Ali Romman",
+  "ai_assistance": "Substantial OpenAI Codex assistance in derivation, implementation, review and verification; independent human and proof-kernel acceptance remain open.",
+  "open_questions": [
+    {
+      "question": "Can this constructor compose with the finite-handle restore/adopt implementation and actual parked caller roots?",
+      "why_it_matters": "The numerical and record bill does not include the complete frontend controller.",
+      "first_step": "Use the source new_context/restore_context replacement path with the actual source root closure and fixed record slots.",
+      "blocked_by": "Caller alias closure, pool/metadata controller and complete parent parking remain separate."
+    }
+  ]
+}
diff --git a/research/qq16-linear-radix-context/VERIFY.json b/research/qq16-linear-radix-context/VERIFY.json
new file mode 100644
index 0000000000..89d768bf6a
--- /dev/null
+++ b/research/qq16-linear-radix-context/VERIFY.json
@@ -0,0 +1,39 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/physical-gaussian-leaf/inputs/pr3087.tar",
+    "research/r437-preparation-composition/PROOF.md",
+    "research/r437-preparation-composition/README.md",
+    "research/r437-preparation-composition/predecessor4025/verify.py"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-W",
+        "error",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 90,
+      "checks": "Exhaustive quotient identity and exact linear bill; literal/shared/fused actual constructors, exact complete invoices, aliases, one-lease capacity, four-word peak, cleanup, rejection rollback and typed receipt."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-W",
+        "error",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 90,
+      "checks": "Exhaustive quotient identity and exact linear bill; literal/shared/fused actual constructors, exact complete invoices, aliases, one-lease capacity, four-word peak, cleanup, rejection rollback and typed receipt."
+    }
+  ]
+}
diff --git a/research/qq16-linear-radix-context/constructor.py b/research/qq16-linear-radix-context/constructor.py
new file mode 100644
index 0000000000..046d97cbb4
--- /dev/null
+++ b/research/qq16-linear-radix-context/constructor.py
@@ -0,0 +1,55 @@
+"""Construct the source Context with one fixed-radix quotient scan per digit.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+Fixed-radix long division follows the retained Natural.divide_small method.
+The loop interchange follows ToikY and Chris R's shared-radix work.
+"""
+
+
+def need(ok,message):
+    if not ok:raise ValueError(message)
+
+
+def divide_fixed(word,q):
+    """q is a compiled constant. Only a remainder below q enters control."""
+    word.msb()
+    remainder=0
+    while (symbol:=word.read())!=2:  # LEFT in the retained word alphabet.
+        need(symbol in (0,1),'binary quotient input')
+        remainder=2*remainder+symbol
+        if remainder>=q:
+            word.write(1);remainder-=q
+        else:word.write(0)
+        word.step(-1)
+    word.step(1)
+    return remainder
+
+
+def build(ring,codes,Context,Count):
+    """Return a genuine Context. The class factories are fixed source bindings."""
+    q,d=codes.q,codes.dimension
+    need(type(q) is int and q>=2 and type(d) is int and d>=1,'compiled context vocabulary')
+    a=ring.arena;raw=ring.raw;protected=set(a.live)
+    value=None;success=False
+    try:
+        power=a.copy(ring.modulus)
+        value=Count()
+        first=True;cap=None
+        while raw.compare(power,ring.one)>0:
+            need(divide_fixed(power,q)==0,'exact radix power')
+            if first:
+                cap=a.copy(power);first=False
+            else:
+                for _ in range(d*d):value.multiply_small(q)
+        need(not first and raw.compare(power,ring.one)==0,'positive radix exponent')
+        a.free(power)
+        context=object.__new__(Context)
+        context.ring,context.arena,context.raw=ring,a,raw
+        context.codes=codes;context.q=q;context.dimension=d
+        context.cap,context.highs=cap,value
+        success=True
+        return context
+    finally:
+        if not success:
+            if value is not None:value.close()
+            a.rollback(protected)
diff --git a/research/qq16-linear-radix-context/vendor/installation_source.py b/research/qq16-linear-radix-context/vendor/installation_source.py
new file mode 100644
index 0000000000..6a661a1062
--- /dev/null
+++ b/research/qq16-linear-radix-context/vendor/installation_source.py
@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""Source-bound numerical constructor and physical count-installation audit.
+
+Mihir Srivastava, substantial OpenAI Codex assistance. Apache-2.0.
+All executed source algorithms come from the authenticated retained archive.
+"""
+import ast
+from contextlib import contextmanager
+import hashlib
+import io
+import itertools
+import json
+from pathlib import Path
+import sys
+import tarfile
+import types
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+ARCHIVE = 'research/physical-gaussian-leaf/inputs/pr3087.tar'
+
+
+def need(ok, why):
+    if not ok:
+        raise ValueError(why)
+
+
+def authenticate():
+    for row in json.loads((HERE / 'SOURCES.json').read_bytes())['files']:
+        if row['usage'] == 'input':
+            need(hashlib.sha256((ROOT / row['path']).read_bytes()).hexdigest()
+                 == row['sha256'], 'source pin: ' + row['path'])
+
+
+def load_source():
+    data = (ROOT / ARCHIVE).read_bytes()
+    for path in ('inputs/pr3055.tar', 'inputs/pr2899.tar', 'inputs/pr2809.tar'):
+        with tarfile.open(fileobj=io.BytesIO(data)) as archive:
+            data = archive.extractfile(path).read()
+    with tarfile.open(fileobj=io.BytesIO(data)) as archive:
+        sources = {member.name: archive.extractfile(member).read()
+                   for member in archive.getmembers() if member.isfile() and member.name.endswith('.py')}
+    vendor = 'inputs/pr2753/predecessor/vendor/'
+    modules = {}
+    def module(name, path):
+        obj = types.ModuleType(name)
+        obj.__file__ = path
+        sys.modules[name] = obj
+        exec(compile(sources[path], path, 'exec'), obj.__dict__)
+        modules[name] = obj
+        return obj
+    for name in ('words', 'records', 'stream', 'cardinality', 'counts'):
+        module(name, vendor + name + '.py')
+    module('cardinal_counts', 'inputs/pr2753/predecessor/cardinal_counts.py')
+    module('directory', vendor + 'directory.py')
+    w, r = modules['words'], modules['records']
+    namespace = dict(Tape=r.Tape, Arena=w.Arena, Meter=w.Meter, BLANK=w.BLANK,
+                     LEFT=w.LEFT, need=w.need, contextmanager=contextmanager,
+                     sys=sys, FunctionType=types.FunctionType)
+    def definitions(path, names, target):
+        tree = ast.parse(sources[path])
+        nodes = [n for n in tree.body if isinstance(n, (ast.ClassDef, ast.FunctionDef)) and n.name in names]
+        need({n.name for n in nodes} == set(names), 'complete source definition slice')
+        exec(compile(ast.Module(body=nodes, type_ignores=[]), path, 'exec'), target)
+    definitions('scratch_pool.py', {'Lease', 'ScratchPool'}, namespace)
+    definitions('macro_binding.py', {'view'}, namespace)
+    namespace.update(Count=modules['cardinal_counts'].Count,
+                     Context=modules['directory'].Context, Ring=w.Ring,
+                     Unsigned=w.Unsigned, Program=r.Program,
+                     append_tape=modules['directory'].append_tape)
+    tree = ast.parse(sources['macro_machine.py'])
+    machine = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == 'Machine')
+    names = {'tape', 'count', 'commit', 'save_count', 'new_context'}
+    methods = [n for n in machine.body if isinstance(n, ast.FunctionDef) and n.name in names]
+    need({n.name for n in methods} == names, 'complete constructor method slice')
+    cls = ast.ClassDef(name='Machine', bases=[], keywords=[], body=methods, decorator_list=[])
+    exec(compile(ast.fix_missing_locations(ast.Module(body=[cls], type_ignores=[])),
+                 'macro_machine.py:constructor-slice', 'exec'), namespace)
+    # Bind the caller's actual precondition: streams park before new_context.
+    call = next(n for n in machine.body if isinstance(n, ast.FunctionDef) and n.name == 'call')
+    calls = [ast.unparse(n.value.func) for n in call.body
+             if isinstance(n, ast.Expr) and isinstance(n.value, ast.Call)]
+    need(calls.index('self.streams.park') < calls.index('self.new_context'), 'source CALL parks before replacement')
+    load = next(n for n in machine.body if isinstance(n, ast.FunctionDef) and n.name == 'load_root')
+    need(any(isinstance(n, ast.Call) and ast.unparse(n.func) == 'self.new_context'
+             for n in ast.walk(load)), 'source root constructor call')
+    return modules, namespace, sources
+
+
+@contextmanager
+def allocated_from(modules, pool, Tape):
+    """Specialize only the loaded allocation sites, as source install does.
+
+    This does not execute the complete install hook or selected loader. Each
+    source module retains a separate globals namespace, including both Counts.
+    """
+    changed = []
+    for module in modules.values():
+        for name, value in tuple(vars(module).items()):
+            if value is Tape:
+                changed.append((module, name, value))
+                setattr(module, name, pool.acquire)
+    original_init = Tape.__init__
+    def forbidden(*_args, **_kwargs):
+        raise ValueError('unexpected physical Tape allocation')
+    Tape.__init__ = forbidden
+    try:
+        yield
+    finally:
+        Tape.__init__ = original_init
+        for module, name, value in reversed(changed):
+            setattr(module, name, value)
+
+
+def counts(tapes):
+    return tuple(sum(getattr(t.meter, field) for t in tapes)
+                 for field in ('reads', 'writes', 'moves'))
+
+
+def body(tape, blank):
+    return bytes(tape.cells[1:]).rstrip(bytes([blank]))
+
+
+def expected_install(n, dirty):
+    # n includes the RIGHT delimiter; dirty is the previous dense body length.
+    return 7*n + 2*dirty + 10, 2*n + dirty, 6*n + 2*dirty + 14
+
+
+def run_case(modules, ns, q, width, dimension, dirty=0, capacity=2,
+             early_close=False, wrong_view=False):
+    w, r = modules['words'], modules['records']
+    modulus_value = q**width
+    arena = w.Arena(modulus_value.bit_length()+1, 32)
+    indices = w.Arena(8, 8)
+    modulus = arena.input(modulus_value)
+    size, depth = indices.input(2*dimension), indices.input(1)
+    highs, program, spectator = r.Tape(), r.Tape(), r.Tape()
+    for i in range(dirty):
+        highs.append((i+1) & 1)
+    highs.rewind()
+    for tape in (program, spectator):
+        for bit in (1, 0, 1, 1, 0):
+            tape.append(bit)
+        tape.rewind()
+    protected = [(t, bytes(t.cells), t.head) for t in (program, spectator)]
+    pool = ns['ScratchPool'](capacity)
+    runtime = object.__new__(ns['Machine'])
+    runtime.arena, runtime.indices = arena, indices
+    runtime.binding = types.SimpleNamespace(codes=types.SimpleNamespace(q=q, dimension=dimension, bits=7))
+    runtime.roles = {'highs': highs, 'program': program, 'spectator': spectator}
+    observation = {}
+    def observed_save(self, value, label):
+        need(isinstance(value.tape, ns['Lease']), 'source count uses a scratch lease')
+        source = value.tape.physical
+        observation['lease'] = value.tape
+        observation['n'] = len(body(source, w.BLANK))
+        observation['source_value'] = sum(bit << i for i, bit in enumerate(body(source, w.BLANK)[:-1]))
+        if early_close:
+            value.close()
+        before = counts((source, highs))
+        ns['Machine'].save_count(self, value, label)
+        observation['install'] = tuple(b-a for a, b in zip(before, counts((source, highs))))
+    runtime.save_count = types.MethodType(observed_save, runtime)
+    with allocated_from(modules, pool, r.Tape):
+        runtime.new_context(modulus, size, depth)
+    if wrong_view:
+        runtime.context.highs.tape = program
+    expected = q**((width-1)*dimension*dimension)
+    encoding = bytes((expected >> i) & 1 for i in range(expected.bit_length())) + bytes([w.RIGHT])
+    need(body(highs, w.BLANK) == encoding and observation['source_value'] == expected,
+         'exact high count and canonical encoding')
+    need(runtime.context.highs.tape is highs and runtime.program.tape is program,
+         'installed fixed Tape views')
+    need(runtime.context.cap.inspect() == q**(width-1), 'exact high-field radix')
+    need(runtime.context.raw is runtime.context.ring.raw and runtime.context.ring.modulus is modulus,
+         'retained numerical aliases')
+    need(observation['install'] == expected_install(len(encoding), dirty), 'exact installation operation counts')
+    need(pool.peak == 2 and pool.allocations == 2, 'exact two-lease constructor')
+    pool.empty()
+    need(highs.head == program.head == spectator.head == 1 and
+         all(arena.words[i].head == 1 for i in arena.live) and
+         all(indices.words[i].head == 1 for i in indices.live), 'canonical constructor heads')
+    need(arena.live == {modulus.slot, runtime.context.ring.one.slot, runtime.context.cap.slot},
+         'no temporary numerical words after constructor')
+    need(all(bytes(t.cells) == data and t.head == head for t, data, head in protected),
+         'dirty program and spectator preservation')
+    # The ended result lease uses slot one; force reuse of that exact slot.
+    first, second = pool.acquire(), pool.acquire()
+    need(second.physical is observation['lease'].physical, 'same physical scratch role reused')
+    second.append(1); second.append(w.RIGHT); second.rewind()
+    saved = bytes(second.physical.cells), second.physical.head
+    observation['lease'].clear()
+    need((bytes(second.physical.cells), second.physical.head) == saved and second.active,
+         'ended lease cannot erase later borrower')
+    first.clear(); second.clear(); pool.empty()
+    runtime.context.close()
+    runtime.context.ring.close()
+    arena.free(modulus); indices.free_many(size, depth)
+    need(not arena.live and not indices.live and not body(highs, w.BLANK), 'owned constructor cleanup')
+    return {'q': q, 'w': width, 'd': dimension, 'dirty': dirty, 'value': str(expected),
+            'n': len(encoding), 'install': observation['install'], 'peak': 2}
+
+
+def reject(action, message):
+    try:
+        action()
+    except ValueError as error:
+        need(message in str(error), 'specific rejection: ' + str(error))
+        return
+    raise ValueError('negative control accepted: ' + message)
+
+
+def main():
+    authenticate()
+    modules, ns, sources = load_source()
+    cases = [run_case(modules, ns, q, width, dimension, dirty)
+             for q, width, dimension, dirty in itertools.product((2, 3, 5), (1, 2, 3), (1, 2, 4), (0, 1, 7))]
+    cases.append(run_case(modules, ns, 3, 3, 8, 31))
+    reject(lambda: run_case(modules, ns, 3, 2, 2, capacity=1), 'fixed scratch role inventory exhausted')
+    reject(lambda: run_case(modules, ns, 3, 2, 2, early_close=True), 'live scratch lease')
+    reject(lambda: run_case(modules, ns, 3, 2, 2, wrong_view=True), 'installed fixed Tape views')
+    witness = next(c for c in cases if (c['q'],c['w'],c['d'],c['dirty']) == (3,2,2,0))
+    need(witness['value'] == '81' and witness['n'] == 8, 'dimension-square positive discriminator')
+    need(int(witness['value']) != 3**2, 'dimension-linear exponent rejected')
+    need(witness['install'] != (expected_install(8,0)[0]-1, 16, 62), 'one-read undercharge rejected')
+    need(expected_install(8,7) != expected_install(8,0), 'dirty overwrite cannot use empty tariff')
+    result = {'status': 'PASS_QQ16_HIGH_COUNT_INSTALLATION', 'cases': len(cases),
+              'executed_rejection_controls': 3, 'arithmetic_discriminators': 3, 'witness': witness,
+              'largest_count_bits': max(c['n']-1 for c in cases),
+              'source_members_sha256': {path: hashlib.sha256(sources[path]).hexdigest()
+                  for path in ('macro_machine.py','scratch_pool.py','macro_binding.py',
+                    'inputs/pr2753/predecessor/vendor/counts.py',
+                    'inputs/pr2753/predecessor/vendor/directory.py')}}
+    print(json.dumps(result, sort_keys=True))
+
+
+if __name__ == '__main__':
+    main()
diff --git a/research/qq16-linear-radix-context/verify.py b/research/qq16-linear-radix-context/verify.py
new file mode 100644
index 0000000000..8b5bb4711f
--- /dev/null
+++ b/research/qq16-linear-radix-context/verify.py
@@ -0,0 +1,133 @@
+"""Compare the actual source constructor, shared traversal and fused producer.
+
+Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+The source loader and installation fixture retain Mihir Srivastava's credit.
+"""
+import argparse,ast,hashlib,json,sys,types
+from pathlib import Path
+
+P=Path(__file__).resolve().parent;ROOT=P.parents[1]
+
+
+def need(ok,message):
+    if not ok:raise ValueError(message)
+
+
+def load(name,path):
+    obj=types.ModuleType(name);obj.__file__=str(path);sys.modules[name]=obj
+    exec(compile(path.read_bytes(),str(path),'exec'),obj.__dict__);return obj
+
+
+for row in json.loads((P/'SOURCES.json').read_text())['files']:
+    if row['usage']=='input':path=ROOT/row['path']
+    elif row.get('pin'):path=P/'vendor/installation_source.py'
+    else:continue
+    need(hashlib.sha256(path.read_bytes()).hexdigest()==row['sha256'],'source hash')
+old=load('installation_source',P/'vendor/installation_source.py');old.ROOT=ROOT
+new=load('constructor',P/'constructor.py')
+mods,ns,sources=old.load_source()
+w=mods['words'];r=mods['records']
+shared_path=ROOT/'research/r437-preparation-composition/predecessor4025/verify.py'
+tree=ast.parse(shared_path.read_bytes());nodes=[n for n in tree.body if isinstance(n,ast.FunctionDef) and n.name=='high_power_shared']
+need(len(nodes)==1,'exact shared source function');scope={};exec(compile(ast.Module(body=nodes,type_ignores=[]),str(shared_path),'exec'),scope)
+
+
+def actions(m):return m.reads+m.writes+m.moves
+
+
+def run_case(q,width,d,mode,dirty=0):
+    M=q**width;B=M.bit_length()+1;arena=w.Arena(B,32);indices=w.Arena(8,8)
+    modulus=arena.input(M);size,depth=indices.input(2*d),indices.input(1)
+    highs,program,spectator=r.Tape(),r.Tape(),r.Tape()
+    for _ in range(dirty):highs.append(1)
+    highs.rewind()
+    for tape in (program,spectator):
+        for bit in (1,0,1,1,0):tape.append(bit)
+        tape.rewind()
+    protected=[(t,bytes(t.cells),t.head) for t in (modulus,size,depth,program,spectator)]
+    pool=ns['ScratchPool'](1 if mode=='fused' else 2)
+    runtime=object.__new__(ns['Machine']);runtime.arena,runtime.indices=arena,indices
+    runtime.binding=types.SimpleNamespace(codes=types.SimpleNamespace(q=q,dimension=d,bits=7))
+    runtime.roles={'highs':highs,'program':program,'spectator':spectator}
+    old_context=ns['Context'];old_high=mods['counts'].high_power;old_div=w.Unsigned.divmod
+    phase={};divisions=0
+    def observed_div(self,a,b):
+        nonlocal divisions
+        divisions+=1;return old_div(self,a,b)
+    def context_factory(ring,codes):
+        start=actions(arena.meter);rec=sum(actions(t.meter) for t in pool.tapes)
+        context=new.build(ring,codes,old_context,mods['counts'].Count) if mode=='fused' else old_context(ring,codes)
+        phase['word']=actions(arena.meter)-start;phase['record']=sum(actions(t.meter) for t in pool.tapes)-rec
+        return context
+    ns['Context']=context_factory;w.Unsigned.divmod=observed_div
+    if mode=='shared':mods['counts'].high_power=lambda value,ring,q,d:scope['high_power_shared'](value,ring,q,d,mods['cardinality'].radix_power)
+    start=actions(arena.meter)+sum(actions(t.meter) for t in (*pool.tapes,highs,program,spectator))
+    try:
+        with old.allocated_from(mods,pool,r.Tape):runtime.new_context(modulus,size,depth)
+    finally:ns['Context']=old_context;mods['counts'].high_power=old_high;w.Unsigned.divmod=old_div
+    total=actions(arena.meter)+sum(actions(t.meter) for t in (*pool.tapes,highs,program,spectator))-start
+    value=q**((width-1)*d*d);N=value.bit_length();encoding=bytes((value>>i)&1 for i in range(N))+bytes([w.RIGHT])
+    need(old.body(highs,w.BLANK)==encoding,'actual installed high count')
+    need(type(runtime.context) is old_context and runtime.context.cap.inspect()==q**(width-1),'genuine Context and cap')
+    need(runtime.context.raw is runtime.context.ring.raw and runtime.context.ring.modulus is modulus,'numerical alias preservation')
+    need(runtime.context.highs.tape is highs and runtime.program.tape is program,'literal installed Tape aliases')
+    need(all(bytes(t.cells)==data and t.head==head for t,data,head in protected),'protected bytes and heads')
+    need(arena.live=={modulus.slot,runtime.context.ring.one.slot,runtime.context.cap.slot},'constructor numerical cleanup')
+    need(all(arena.words[i].head==1 for i in arena.live),'returned numerical heads')
+    pool.empty()
+    if mode=='fused':
+        m=d*d*(width-1);sum_bits=sum((q**j).bit_length() for j in range(m))
+        word=(14*width+59)*B+21*width+80
+        record=23+6*sum_bits+4*(N-1)+5*m
+        need(phase==dict(word=word,record=record),'exact fused production invoice')
+        need(total==22*B+41+word+record+15*(N+1)+5*dirty+24,'exact complete constructor invoice')
+        need(pool.peak==pool.allocations==1 and arena.meter.peak_live==4,'one lease and four numerical words')
+        need(divisions==0,'no general division in fused constructor')
+    else:need(divisions==((d*d+1)*width+1 if mode=='literal' else 2*width+1),'retained general-division count')
+    result=dict(q=q,w=width,d=d,B=B,dirty=dirty,mode=mode,actions=total,production=phase,general_divisions=divisions,record_peak=pool.peak,numerical_peak=arena.meter.peak_live,count_bits=N)
+    runtime.context.close();runtime.context.ring.close();arena.free(modulus);indices.free_many(size,depth)
+    need(not arena.live and not indices.live and not old.body(highs,w.BLANK),'complete output disposal')
+    return result
+
+
+def quotient_cases():
+    n=0
+    for B in range(2,8):
+        for q in range(2,8):
+            for value in range(2**B):
+                arena=w.Arena(B,1);word=arena.input(value);before=actions(arena.meter)
+                rem=new.divide_fixed(word,q)
+                need(actions(arena.meter)-before==5*B+7,'exact quotient scan invoice')
+                need((word.inspect(),rem)==divmod(value,q),'independent quotient identity');n+=1
+    return n
+
+
+def rejecting():
+    n=0
+    for q,M in ((2,3),(3,12),(5,26),(3,2)):
+        arena=w.Arena(M.bit_length()+1,8);modulus=arena.input(M);ring=w.Ring(modulus)
+        before=set(arena.live);saved=[(t,bytes(t.cells),t.head) for t in (modulus,ring.one)]
+        pool=ns['ScratchPool'](1)
+        try:
+            with old.allocated_from(mods,pool,r.Tape):new.build(ring,types.SimpleNamespace(q=q,dimension=2),ns['Context'],mods['counts'].Count)
+        except ValueError as error:need('radix' in str(error),'specific radix rejection');n+=1
+        else:raise ValueError('accepted non-power')
+        need(arena.live==before and all(bytes(t.cells)==data and t.head==head for t,data,head in saved),'rejection rollback')
+        pool.empty();ring.close();arena.free(modulus)
+    return n
+
+
+def main():
+    ap=argparse.ArgumentParser();ap.add_argument('--write-result',action='store_true');args=ap.parse_args()
+    quotient=quotient_cases();rows=[]
+    fixtures=[(q,width,d,dirty) for q,width,d,dirty in ((2,1,1,0),(3,2,2,0),(5,3,2,7),(3,4,4,31),(5,8,4,0),(3,2,8,0),(3,1,64,0))]
+    for q,width,d,dirty in fixtures:
+        triple=[run_case(q,width,d,mode,dirty) for mode in ('literal','shared','fused')]
+        need(triple[2]['actions']<triple[1]['actions']<=triple[0]['actions'],'matched full constructor improvement');rows.append(triple)
+    result=dict(status='PASS_LINEAR_RADIX_CONTEXT',quotient_cases=quotient,constructor_comparisons=rows,rejection_controls=rejecting(),constructor_sha256=hashlib.sha256((P/'constructor.py').read_bytes()).hexdigest())
+    if args.write_result:(P/'RESULT.json').write_text(json.dumps(result,indent=2,sort_keys=True)+'\n')
+    else:need(result==json.loads((P/'RESULT.json').read_text()),'complete typed receipt')
+    print(json.dumps(dict(status=result['status'],quotient_cases=quotient,contexts=3*len(rows),rejection_controls=result['rejection_controls'],largest_comparison=rows[4]),sort_keys=True))
+
+
+if __name__=='__main__':main()

From 999b3e03adc30cdf602a4fe4abd2f24547484a66 Mon Sep 17 00:00:00 2001
From: Ali Romman <226877337+aliromman@users.noreply.github.com>
Date: Fri, 23 Oct 2026 15:26:25 -0500
Subject: [PATCH 2/2] Bind context fixture to retained publication history

---
 research/qq16-linear-radix-context/README.md    | 5 ++++-
 research/qq16-linear-radix-context/SOURCES.json | 7 ++++---
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/research/qq16-linear-radix-context/README.md b/research/qq16-linear-radix-context/README.md
index d3c3e0b050..70dfc85218 100644
--- a/research/qq16-linear-radix-context/README.md
+++ b/research/qq16-linear-radix-context/README.md
@@ -49,7 +49,10 @@ Base 7c472563474e60185e6ca101a17622133d047e56, priority 7. Current main, the liv
 Context handoff, all-state numerical-producer PR search and relevant main notes
 were checked. Arbitrary historical diffs and unpublished work remain outside
 coverage. [SOURCES.json](SOURCES.json) pins all inputs. The byte-exact fixture
-in vendor/ is consumed from pending PR5363; its status is explicit.
+in vendor/ is consumed from pending PR5363; its status is explicit. Replay
+pins resolve to that retained copy in this PR history. The upstream_pin
+retains the original commit and path. Thus a clean checkout does not need
+the unmerged predecessor commit.
 
 ToikY supplied shared traversal; Chris R/Clear1nsight applied it to Context.
 Mihir Srivastava supplied the high-count installation audit and source loader.
diff --git a/research/qq16-linear-radix-context/SOURCES.json b/research/qq16-linear-radix-context/SOURCES.json
index b65b2640f1..7f03bef49f 100644
--- a/research/qq16-linear-radix-context/SOURCES.json
+++ b/research/qq16-linear-radix-context/SOURCES.json
@@ -39,11 +39,12 @@
       "sha256": "b2c72707bebb9ecdba2b89675830439393e6e13c76f68dad20d42d6ef70e539a"
     },
     {
-      "path": "research/qq16-high-count-installation/verify.py",
+      "path": "research/qq16-linear-radix-context/vendor/installation_source.py",
       "usage": "provenance",
-      "pin": "head:5ac02c05ad29f4b136cab8fb787985a1ea64de80:research/qq16-high-count-installation/verify.py",
+      "pin": "head:ba57b98b3e76b7f557bef6faa82a9d75d49af9e5:research/qq16-linear-radix-context/vendor/installation_source.py",
       "git_blob": "6a661a1062409f527baaff94ff68f5677881e3cc",
-      "sha256": "7ca1094ad0a3d6d33c1c51f651c87d1ce10bc2f5aee03e6bae2f93aea7bb325f"
+      "sha256": "7ca1094ad0a3d6d33c1c51f651c87d1ce10bc2f5aee03e6bae2f93aea7bb325f",
+      "upstream_pin": "head:5ac02c05ad29f4b136cab8fb787985a1ea64de80:research/qq16-high-count-installation/verify.py"
     }
   ]
 }