diff --git a/research/selected-rank-control/GENERAL-CONTROL-PROOF.md b/research/selected-rank-control/GENERAL-CONTROL-PROOF.md
new file mode 100644
index 0000000000..a2cfd54a94
--- /dev/null
+++ b/research/selected-rank-control/GENERAL-CONTROL-PROOF.md
@@ -0,0 +1,171 @@
+# Online rank-dependent recursion on three fixed tapes
+
+Prepared for @CubeJerry with substantial OpenAI assistance; Apache-2.0.
+Written all-width theorem with finite executable corroboration. No kernel proof.
+
+## 1. Domain and theorem
+
+Fix integers m>=2 and a nonempty ordered paid list (r_0,...,r_(s-1)), with
+1<=r_i<m. These are compile-time constants. For every positive width f, stop
+if f<m; otherwise visit all s ordered children of widths floor(r_i*f/m).
+Repeated equal ranks remain distinct child sites. Set rho=max_i(r_i/m)<1.
+Every internal child width lies in [1,f-1], so the tree is finite.
+
+Input: a marked unary WIDTH stream 1^f, marked-empty CHILD, and STACK at a
+blank top h immediately after its original separator. The entire stack below
+that separator is arbitrary over the finite alphabet. Origins may be translated
+independently. Unused suffixes are blank. K0 counts every retained entry cell,
+including arbitrary warm blank backing; it is never declared free by erasure.
+
+The literal three-tape program has exactly
+
+    Q = 10m+13+s(67+3m)+2*sum_i r_i
+
+instruction locations and s+4 symbols. It emits the ordered contour, restores
+all initial cells and heads, never visits STACK below h-1 and never writes
+below h. No input length, supplied depth/tree, host recursion, run-time
+arithmetic, dynamic tape selector or input-sized alphabet chooses an action.
+If f_v denotes each visited node width and D is the maximum number of descents,
+its complete transition count satisfies
+
+    T <= 100(s+1)*sum_v f_v.
+
+Time depends on s. Retained allocation satisfies
+
+    S <= K0+2(f+2)+f/(1-rho)+D+2
+       <= K0+(3+1/(1-rho))*f+6.
+
+Only the backing bound is independent of sibling count. The latter inequality
+uses D<=f-1; it deliberately has slack. All historically visited erased prefixes
+are included. The finite program is machine control, not run-time storage;
+compiling a different fixed profile is outside this theorem.
+
+## 2. Machine and interface
+
+`controller.py` compiles read, write, unit-move, goto, emit and halt instructions.
+Each is one global multitape transition; unmentioned tapes stay stationary.
+Reads branch solely on the scanned symbol. An emit is a labelled stationary
+finite-control edge: E for internal entry, L for leaf, D_i for descent at site i,
+U_i for return at site i, and X for completed node. It does not append to a
+physical event tape. Python event lists, counters and visited-interval logs are
+verifier observations and are never read by an instruction.
+
+A later consumer may be linked to these finite states if its own transitions
+are paid and it preserves the controller's three-tape frame at return. No
+payload consumer or binary external-descriptor conversion is supplied here.
+In particular a materialized event transcript is not free storage.
+
+At enter, the classifier scans at most m WIDTH symbols, rewinds and emits E
+or L. Zero width rejects. Internal entries execute the fixed ordered site list.
+A completed site's finite tag determines the next site or node completion.
+The only changing control value is the finite program state.
+
+## 3. Exact child widths
+
+For fixed rank r, the scanning state stores c in {0,...,m-1}. On each unary
+parent symbol it replaces c by (c+r) mod m and appends a CHILD symbol precisely
+when c+r>=m. After k symbols, CHILD has floor(rk/m) symbols and c=rk mod m.
+Induction on k proves this Euclidean-division invariant. At scan completion,
+n=floor(rf/m), and both heads rewind. For internal f>=m and 1<=r<m, 1<=n<f.
+Termination follows without a depth descriptor or inspecting payloads.
+
+The source's `divmod` constructs finite transitions at compile time. Neither
+`divmod` nor any decoded width appears in `Machine.step`.
+
+## 4. Continuation and restoration
+
+Before descent, parent WIDTH is copied to STACK and erased from WIDTH. The
+fixed site tag t_i is appended. CHILD is moved into WIDTH and physically erased;
+both heads rewind. D_i is emitted and control jumps to the single enter state.
+Thus STACK contains blocks 1^(parent width) t_i along the live ancestor path,
+and its head is at the next blank. It contains no dynamic objects or pointers.
+
+On X, one left move reads the preceding tag. If it is the original separator,
+the root is complete: advance right and halt without erasing root WIDTH.
+Otherwise retire tag t_i, clear/rewind the owned child WIDTH, and copy the
+immediately preceding unary parent block back into WIDTH while erasing it.
+Stop at the preceding tag or original separator, preserve that symbol, move
+STACK right to the old record origin, rewind WIDTH, emit U_i and resume the
+next fixed site. Unary reversal does not alter the restored descriptor.
+
+Induction over the finite tree proves the contour and all exact endpoints.
+Every push writes at or above its entry top. Every pop reads at most its own
+preceding separator and writes only its own record. This proves locality for
+every execution prefix; endpoint restoration alone is not used to infer it.
+The machine never scans farther ancestors. This is a valid-input theorem;
+malformed input need not roll back.
+
+## 5. Complete transition invoice
+
+Literal loop counts for parent f and child n<=f are as follows. They include
+terminal reads, delimiter work, erasures and head returns.
+
+| Phase | Bound |
+| --- | ---: |
+| Generate child and rewind both streams | 6f+5n+8 |
+| Park/erase parent, append tag and rewind | 9f+6 |
+| Move child into WIDTH and rewind both | 12n+7 |
+| D_i and jump to entry | 2 |
+| Erase returned child and rewind | 7n+4 |
+| Pop parent and rewind | 9f+5 |
+| Return dispatch, tag retirement, U_i and successor | 6 |
+
+An n-cell rewind takes 3n+3: one initial left move, three instructions per cell
+and two at the marker. Adding the table gives a round trip outside the child
+execution of at most 48f+38. Entry classification and E/L take at most 6f+7;
+X takes one. The root's final check and halt add at most four.
+Internal local cost is therefore at most s(48f+38)+6f+8 and leaf cost at most
+6f+8, with that root constant. Since every f_v>=1 and s>=1, summing proves
+the stated 100(s+1)*sum_v f_v. Each sibling repeats its own generation and
+park/return bill; no sibling-independent time constant is asserted.
+
+## 6. Retained backing and shape inflation
+
+WIDTH and CHILD remain between their fixed marker and an endpoint at most f
+cells away, including historical prefixes left blank by smaller later uses.
+At an active path f_0=f,f_1,...,f_D, one has f_j<=rho^j*f. STACK holds one
+unary parent and one tag per descent. All its visits lie between h-1 and
+h+sum_(j<D) f_j+D. Adding the three historical tape intervals gives the stated
+K0+2(f+2)+f/(1-rho)+D+2 bound. Every path obeys that same cap and reuses the
+same origins. Erased regions are never reclaimed by assumption.
+
+For m=2, three ranks r_i=1, and root f=2^d, the complete tree has exactly
+(3^(d+1)-1)/2 nodes. A literal one-symbol-per-node contour needs superlinear
+space in f, whereas the online controller uses O(f) backing. The node count is
+the geometric series, not an inference from tests. This observation does not
+exclude other compressed encodings. The verifier's retained event lists are
+outside the machine whose backing is bounded.
+
+## 7. Selected-source compatibility and limitations
+
+The selected #7000 application review, Section 5, keeps the original complete
+D-bit root factor in each descendant and partitions only external ROW axes.
+If a consumer maintains this invariant, supplies at least one complete root
+factor per node, and has f_v<=D, then for D>=1 its logical bit volume satisfies
+V_v>=2^D>=D>=f_v. The producer overhead is consequently at most
+100(s+1)*sum_v V_v, a fixed node-volume fee. This is a conditional implication;
+it does not prove that an actual selected dispatcher has made those grants or
+that its exact rank-rounding rule equals this floor recurrence.
+
+Different cutoffs, remainder jobs, multiple backend types and different rank
+rounding must be bound to actual source before substitution. This producer does
+not emit #6719's H/A/R grants, route payloads, execute native maps or provide
+binary-to-unary input conversion. Stock, numerical precision, ownership of
+payloads and analytic recovery remain separate. All five selected assumptions
+and selected kappa are unchanged.
+
+## 8. Novelty and credit
+
+JoyboyBrian's #5158 already gives physical fixed-bank dyadic complete-row
+recursion. Thu-nmrc's #6719 already gives a richer delayed-cover root, recursive
+grant and payload program from binary inputs and supplied unary depth. ToikY's
+#6722 reviews a specific producer/router join. Their results retain credit;
+this does not claim the first fixed-tape recursion or geometric backing proof.
+
+The delta is the rank-dependent termination and heterogeneous-child shape
+producer with no supplied depth/tree, arbitrary fixed paid branching, an exact
+small transition census and a sibling-independent retained-space bound.
+Finite remainder machines, depth-first stacks and geometric sums are standard.
+This is one enabling interface theorem, with payload integration and external
+descriptor preparation open; no new exponent, assumption discharge, complete
+multiplier, independent human verification or proof-kernel acceptance is claimed.
diff --git a/research/selected-rank-control/PR-DESCRIPTION.md b/research/selected-rank-control/PR-DESCRIPTION.md
new file mode 100644
index 0000000000..6e47867030
--- /dev/null
+++ b/research/selected-rank-control/PR-DESCRIPTION.md
@@ -0,0 +1,104 @@
+## What changed and why
+
+The physical caller work already supports fixed-bank recursion. Binding that
+work to the selected finite compiler still requires exact runtime child
+widths, stopping control and paid remainder handling. This package supplies a
+literal control producer for the final rank-one law, backed by a general
+rank-profile lemma and source-pinned cutoff/remainder analysis.
+
+The raw mixed-rank BIT law is r_i floor(e/m), not floor(r_i e/m). The selected
+finite-precompilation source instead makes every final paid leaf rank one, so
+all P child calls have width floor(e/N). The source binding makes this
+distinction explicit and retains the supplied root cutoff L.
+
+## Exact result
+
+For fixed N >= 2 and P >= 1, a four-tape finite controller stops below
+max(N,L), generates the ordered rank-one calls and emits pre/post hooks for
+e mod N. It restores unary descriptors, the cutoff tape and arbitrary
+suspended ancestors. Every return, head rewind and hook dispatch is paid.
+
+- Instruction count: 30N+42+P(69+3N), independent of e and L.
+- Complete control time: at most 200(P+1) sum_v e_v.
+- Retained backing: at most K0+(4+N/(N-1))e_root+8; K0 includes the entire
+  supplied cutoff and preexisting historical backing.
+- Cutoff comparison: at most 11 min(e,L)+10, including both head returns.
+- Each remainder scan: 6e+7; both scans: 12e+14. B0/A0 explicitly skip
+  remainder payload actions, with finite dispatch still paid.
+
+The reusable three-tape lemma supports arbitrary fixed 1 <= r_i < m and
+children floor(r_i f/m), with complete time 100(s+1) sum_v f_v and retained
+backing K0+(3+1/(1-rho))f_root+6. It requires no supplied tree or depth.
+
+The all-width results are proved by explicit loop and stack invariants.
+The conditional node-volume corollary additionally assumes complete-root
+factors/row stock and paid payload consumers. It does not establish those
+interfaces.
+
+## Novelty and predecessors
+
+#5134 and #5158 already provide literal complete-row parking and dyadic
+fixed-bank recursion. #6719 provides the richer supplied-depth delayed-cover
+binary-root/grant/payload program; #6722 reviews a particular join. They
+retain credit. The present delta is online rank-dependent shape control and
+its exact final rank-one cutoff/remainder connection, with no raw mixed-floor
+substitution. Classical finite remainder transducers and depth-first stacks
+are standard techniques.
+
+Pending #7150 and #7151 cover primitive microcontrol and stratified retained
+backing. Their inspected heads are pinned as complementary work, not merged
+dependencies. The scientific base is
+`e54523517d0f03e58352e647c403a5af3e525a57`; `SOURCES.json` pins the actual
+batched-row notes, finite-precompilation source, #7000 review and predecessor
+proofs by commit/blob/hash.
+
+## Reproduction and checks
+
+```sh
+python3 -B research/selected-rank-control/verify_all.py
+```
+
+Expected: `PASS_SELECTED_RANK_CONTROL_PACKAGE`. This runs each bounded suite
+normally and under `-O`, requiring byte-identical receipts.
+
+- General: 896 cases, 13,540 nodes, 3,469,732 transitions, nine separate dense
+  CPU cases and ten negative controls.
+- Selected: 2,400 cases, 10,878 nodes, 3,443,893 transitions, eight separate
+  dense CPU cases and eight controls.
+- Checks observe actual unary widths as well as labels; they cover cutoff
+  equality, restored heads/cells, ancestor locality, historical backing,
+  remainder identity/omission, wrong return tags and undercharged execution.
+
+Proofs, finite receipts and validation metadata are included. Finite checks
+corroborate universal written proofs; neither interpreter is a formal kernel.
+Normal execution and optimized execution are regression checks, not separate
+mathematical proofs.
+
+
+A separate reviewer read both proofs and executed a code-disjoint dense CPU
+against an explicit address-tree oracle. It passed 125 cases, 837 nodes,
+3,654 events and 488,423 transitions, checking actual widths, full ancestor
+stacks, hostile exterior cells and 556 exact remainder-scan charges. Three
+semantic mutants were rejected. From this directory run
+`python3 -I -W error -B independent_check.py .`; see REVIEW.md and
+evidence/independent.json for the complete independent receipt.
+
+## Limitations and kappa status
+
+**No new kappa. All five selected foundational assumptions remain.** The
+accepted conditional kappa stays 0.00363005817. This is a control/interface
+lemma, not a complete multiplication implementation or unconditional theorem.
+
+The actual selected final word and its owner manifest are not emitted. The
+external width/cutoff adapter, row grants, chronological scalar/frame segments,
+both BIT remainder consumers and complete native endpoint contracts remain
+open. Generating L=ceil(d^beta) is not free. Consumers must preserve descriptor
+tapes and pay their work; complex remainder completion and BIT ungathering are
+not supplied by the event producer.
+
+## Attribution
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Credit JoyboyBrian,
+thu-nmrc, ToikY, commdata2338, Ali Romman, David Arias and all retained native,
+physical and compiler contributors. New material is Apache-2.0. Independent
+human review and formal-kernel acceptance are not claimed.
diff --git a/research/selected-rank-control/PR-TITLE.txt b/research/selected-rank-control/PR-TITLE.txt
new file mode 100644
index 0000000000..92d819b9ba
--- /dev/null
+++ b/research/selected-rank-control/PR-TITLE.txt
@@ -0,0 +1 @@
+Generate the selected rank-one recursion on fixed tapes with paid cutoff comparison and two-sided remainder hooks
diff --git a/research/selected-rank-control/README.md b/research/selected-rank-control/README.md
new file mode 100644
index 0000000000..dbd25b5f78
--- /dev/null
+++ b/research/selected-rank-control/README.md
@@ -0,0 +1,131 @@
+# Produce the selected rank-one call control with paid cutoff and remainder hooks
+
+This package supplies a fixed-tape control producer for a fixed compiled
+rank-N word with P rank-one paid sites. It generates children of width
+floor(e/N), applies a supplied root cutoff L, emits both pre- and post-remainder
+hooks for e mod N, and restores every descriptor head and suspended ancestor.
+The source-law connection is to the retained finite-precompilation and
+batched-row notes at main
+`e54523517d0f03e58352e647c403a5af3e525a57`.
+
+The universal control bound is **200(P+1) sum_v e_v** literal transitions,
+including all returns, rewinds and zero-remainder dispatches. Additional
+historical backing is linear in the root width; the supplied cutoff and any
+older backing are explicitly included in entry K0. The actual final selected
+word, cutoff producer, row grants and payload consumers remain obligations.
+**No new kappa and no discharge of a full framework assumption.**
+
+## Two proved layers
+
+| Layer | Exact control law | Tapes and complete control time |
+| --- | --- | --- |
+| General rank profile | Fixed m >= 2, ordered 1 <= r_i < m; child floor(r_i f/m); stop below m | Three; at most 100(s+1) sum_v f_v |
+| Source-compatible final template | Fixed N >= 2 and P paid sites; child floor(e/N); stop below max(N,L); hooks B_r and A_r for r=e mod N | Four; at most 200(P+1) sum_v e_v |
+
+[GENERAL-CONTROL-PROOF.md](GENERAL-CONTROL-PROOF.md) proves the finite remainder
+transducer, parent-width stack, completed-call restoration and retained-space
+bounds. Its historical filename `controller.py` refers to the byte-identical
+`controller_reference.py` supplied here. The general example m=3, ranks (1,2,2)
+has 281 instruction locations and seven symbols. No depth or call tree is
+supplied. Time depends on the fixed paid-list length; backing is reused across
+completed siblings.
+
+[SOURCE-BINDING.md](SOURCE-BINDING.md) proves the exact rank-one specialization,
+the cutoff comparator, remainder hooks and conditional node-volume invoice.
+The N=3,P=2 program has 288 instruction locations, six symbols and four tapes.
+The cutoff comparison costs at most 11 min(e,L)+10 and preserves L. A remainder
+scan costs 6e+7; both scans cost 12e+14. Zero-remainder hooks remain explicit,
+and consumers skip their remainder payload action. Nonzero remainder consumer
+work is charged separately. Ordinary scalar/frame segments between paid calls
+attach to the initial hook and return hooks in their source order.
+
+The distinction between the two layers matters. The raw BIT note has child
+width r_i floor(e/m), which generally differs from floor(r_i e/m). The final
+precompiled word instead has rank-one paid leaves, where the laws agree. This
+package does not substitute the general law into the raw mixed-rank circuit.
+
+## Reproduction and evidence
+
+Python 3.10+ and standard library only. From the repository root:
+
+```sh
+python3 -B research/selected-rank-control/verify_all.py
+```
+
+Expected status: `PASS_SELECTED_RANK_CONTROL_PACKAGE`. The wrapper executes
+both suites normally and under `-O`, requiring byte-identical receipts. To run
+each separately:
+
+```sh
+python3 -B research/selected-rank-control/verify_general.py
+python3 -O -B research/selected-rank-control/verify_general.py
+python3 -B research/selected-rank-control/verify_selected.py
+python3 -O -B research/selected-rank-control/verify_selected.py
+```
+
+The bounded general suite covers 896 cases, 13,540 nodes and 3,469,732
+transitions; nine translated cases use a separately implemented dense CPU and
+ten controls target invalid profiles, wrong floors, wrong returns, leaked
+scratch and false time bounds. The selected suite covers 2,400 cases, 10,878
+nodes and 3,443,893 transitions; eight dense-CPU cases and eight controls check
+cutoff equality, restored unary widths, both remainder hooks, cutoff motion
+and the raw mixed-floor mismatch. Event logs are verifier observations, not
+machine storage. Finite executions corroborate the written all-width proofs;
+no formal proof-kernel acceptance is claimed. Receipts and exact artifact
+hashes appear in `evidence/` and `VALIDATION.json`.
+
+## Prior work and dependency boundary
+
+[#5134](https://github.com/CrocSwap/integer-mult-bounds/pull/5134) supplies the
+literal complete-row parking caller, and
+[#5158](https://github.com/CrocSwap/integer-mult-bounds/pull/5158) already proves
+fixed-bank dyadic complete-row recursion.
+[#6719](https://github.com/CrocSwap/integer-mult-bounds/pull/6719) gives a richer
+delayed-cover binary-root/grant/payload program from a supplied unary depth;
+[#6722](https://github.com/CrocSwap/integer-mult-bounds/pull/6722) reviews a
+particular producer/router join. This package claims the rank-dependent
+online producer and exact final rank-one cutoff/remainder control connection,
+not priority for fixed-tape recursion.
+
+Pending [#7150](https://github.com/CrocSwap/integer-mult-bounds/pull/7150)
+addresses primitive microcontrol; pending
+[#7151](https://github.com/CrocSwap/integer-mult-bounds/pull/7151) addresses
+stratified retained backing. Their inspected heads are recorded in
+`SOURCES.json`. They are complementary references, not assumed merged
+dependencies or substitutes for this package's missing payload integration.
+The selected construction/review in
+[#7000](https://github.com/CrocSwap/integer-mult-bounds/pull/7000) and
+[#7001](https://github.com/CrocSwap/integer-mult-bounds/pull/7001) retains its
+conditional kappa=0.00363005817.
+
+Under an admitted complete-root-factor/row-stock interface, each width e_v is
+at most complete node volume V_v, so control work fits the existing summed
+node-volume bill. The premise does not produce the grants, execute remainder
+kernels or prove frame/ownership contracts. Supplying L=ceil(d^beta) and the
+root width from the actual external input is unpaid until a separate adapter
+is provided. All five assumptions—native_all_columns, owned_erasure, compiler,
+precision_tape and analytic_recovery—remain retained.
+
+## Credit and next obligations
+
+Prepared for @CubeJerry with substantial OpenAI assistance. Credit JoyboyBrian,
+thu-nmrc, ToikY, commdata2338, Ali Romman, David Arias and the retained native,
+physical and compiler contributors. New code and proof text are Apache-2.0.
+The finite remainder transducer, depth-first stack and geometric bounds use
+standard techniques; no broad algorithmic priority claim is made.
+
+Next work is to implement paid external width/cutoff production, instantiate
+the actual selected final paid-site list, and join chronological payload and
+remainder consumers with exact complete-row, tape-frame and return contracts.
+Those tasks remain necessary before treating this control lemma as an
+implementation of the full selected dispatcher.
+
+## Independent review
+
+A separate reviewer read both proofs and executed a code-disjoint dense CPU
+against an explicit address-tree oracle. It passed 125 cases, 837 nodes,
+3,654 events and 488,423 transitions, checking actual widths, full ancestor
+stacks, hostile exterior cells and 556 exact remainder-scan charges. Three
+semantic mutants were rejected. From this directory run
+`python3 -I -W error -B independent_check.py .`; see REVIEW.md and
+evidence/independent.json for the complete independent receipt.
diff --git a/research/selected-rank-control/REVIEW.md b/research/selected-rank-control/REVIEW.md
new file mode 100644
index 0000000000..85ae8b8d41
--- /dev/null
+++ b/research/selected-rank-control/REVIEW.md
@@ -0,0 +1,121 @@
+# Independent review of the selected four-tape controller
+
+**Outcome: PASS for the stated literal control interface.** The independent
+interpreter found no correctness, restoration, transition-envelope or
+historical-interval defect in the tested cases. The code and written loop/
+stack invariants support the universal control claim; finite execution is
+corroboration, not a replacement for that proof. No new kappa or complete
+foundational-assumption discharge follows.
+
+Prepared for Jerry Chen / @CubeJerry by the compiler/source-index worker,
+independently of the controller author, with substantial OpenAI assistance.
+Canonical source base: `e54523517d0f03e58352e647c403a5af3e525a57`.
+
+## Exact reviewed source
+
+Read `SOURCE-BINDING.md`, `GENERAL-CONTROL-PROOF.md`, all of
+`selected_control.py`, and the Builder/instruction definitions in
+`controller_reference.py`. Reviewed SHA256 values:
+
+- `selected_control.py`:
+  `1c977e9f4864d338f874aa4943d9f3422d964c3ab0cc2f877d9bc4c2d9e20237`.
+- `controller_reference.py`:
+  `e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73`.
+- `SOURCE-BINDING.md`:
+  `48ba45eb71df262db7384aa7a8003d9cd2801348c486948cab431528363bf6e5`.
+
+No author file was edited. This review checks execution against the stated
+rank-one law and supplied-cutoff contract; it does not independently certify
+the selected final compiler word or its payload interfaces.
+
+## Independent method
+
+The checker calls only the subject's compile-time Builder/program generator.
+It translates the resulting instructions to a separate six-opcode CPU with
+integer symbol codes, dense read-dispatch tables and four dense tape arrays.
+The author's Machine, Tape and initial_tapes names are replaced by rejecting
+functions before the subject is imported. No author verifier or input helper
+is imported or called.
+
+The oracle first materializes the entire mathematical address tree breadth
+first, using direct integer division and the predicate `e>=max(N,L)`. It then
+assigns phase-order keys to each node's entry, pre-hook, child descent/return,
+post-hook and exit events, and sorts those keys to obtain the contour. This
+is independent of the subject's finite remainder machine and stack control.
+At every emitted edge it compares the label **and the actual unary WIDTH**.
+It also compares the complete active stack with the explicit ancestor list.
+
+Dense buffers, event lists, trees, metrics and observers belong to the
+verifier. They are not used to select a CPU instruction and are not claimed
+as the controller's workspace representation.
+
+## Results and adversarial coverage
+
+Reproduce from this package directory:
+
+```sh
+python3 -I -W error -B independent_check.py . > evidence/independent.json
+```
+
+Observed result: **125 cases, 837 nodes, 3,654 emitted events and 488,423
+literal transitions: PASS.** Every event matched its independently computed
+width and chronological address. The cases use N in {2,3,5,7}, one through
+four paid sites, widths through 4,097, supplied cutoffs through 100,003,
+three independently shifted sets of tape origins, and repeated equal-rank
+paid sites. They include e<N, exact cutoff equality, e=L-1, zero and positive
+remainders, deep branching, and L much larger than e.
+
+The observer checks:
+
+- WIDTH, CHILD and CUTOFF heads at their required origins at every emit;
+  actual parent restoration before U_i and A_r; exact positive child width
+  before D_i.
+- Entire CHILD and unused WIDTH histories blank at every emit, active STACK
+  equal to the explicit ancestor record, and its retired suffix blank.
+- All four tapes and heads restored on halt; no CUTOFF writes; no access below
+  an entry marker. Hostile symbols below markers and beyond each active
+  window remain unchanged, including on the source and scratch tapes.
+- Exact program and alphabet census for every unchanged tested program:
+  `30N+42+P(69+3N)` instruction locations and P+4 symbols.
+- Total transitions, including HALT, below
+  `200(P+1)*sum_v e_v`; the largest measured ratio to this bound is below 0.181.
+- The comparison envelope `11*min(e,L)+10`, and **all 556 pre/post remainder
+  scans** having the exact measured edge-to-edge duration `6e+7`.
+- Historical visited intervals below
+  `2(e+2)+e/(1-1/N)+D+2+min(e,L)+2`, and below its stated linear relaxation.
+  Adding arbitrary entry backing K0 preserves the published bound.
+
+For e=4,097 and L=100,001, the cutoff tape visits only 4,099 cells, while
+its supplied unary input itself occupies 100,003 framed cells. Thus the
+observed prefix bound does not conceal the cost of storing the supplied L;
+the theorem must retain K0 as stated. Hostile exterior tests strengthen
+the observed locality but do not remove the requirement for a valid blank
+active scratch window.
+
+Three semantic negative controls are rejected at the expected independent
+comparison: changing A_1 to A_0; doubling the quotient's emitted unary
+symbols; and treating cutoff equality as a leaf. The second fails on actual
+WIDTH, not merely on its event label. The receipt records all cases and pins.
+
+## Proof assessment and limits
+
+The early N-probe enforces positive strictly smaller children. The later
+comparator reads CUTOFF first, so equality enters; neither finite probe
+requires traversing a larger cutoff. The remainder states advance modulo N
+once per parent token and rewind before their hooks. The parent-width push,
+site tag, transfer, child erasure and pop preserve the exact active ancestor
+record, accounting for chronology and sibling reuse. Post-hook scans occur
+only after the final U_i has restored the parent.
+
+Rank one is essential to this source binding: `1*floor(e/N)=floor(e/N)`.
+This check does not extend raw mixed-rank control to a different integer
+rounding law. B_0/A_0 are finite hooks; their consumers must skip a zero-size
+payload remainder. The supplied cutoff, chronological scalar/frame segments,
+actual row grants, remainder consumers and leaf routine retain their own
+construction, preservation and cost obligations. Emits are control edges,
+not a free materialized event transcript. The selected enormous N/P template
+and the complete multiplication machine remain unmaterialized.
+
+## Root proof and integration review
+
+The orchestrator separately checked the general and source-bound proofs, actual child-width law, cutoff equality, remainder hooks, restored-parent chronology, complete transition invoice and historical intervals. This identified the exact remainder-scan count correction to 6e+7 before the frozen snapshot; the conservative global bound is unchanged. The separate CPU confirms that corrected exact count. Source pins and the declared scope were rechecked before publication. Packaging changes only checker paths and review metadata; scientific controller and proof bytes are unchanged.
diff --git a/research/selected-rank-control/SOURCE-BINDING.md b/research/selected-rank-control/SOURCE-BINDING.md
new file mode 100644
index 0000000000..4950c93e05
--- /dev/null
+++ b/research/selected-rank-control/SOURCE-BINDING.md
@@ -0,0 +1,173 @@
+# Final rank-one control with supplied root cutoff and paid remainder hooks
+
+Base: `e54523517d0f03e58352e647c403a5af3e525a57`. Prepared for @CubeJerry with
+substantial OpenAI assistance; Apache-2.0. This refines the online controller's
+source boundary. The earlier package remains unchanged. No new kappa or
+framework-assumption discharge is claimed.
+
+## 1. Exact source law, including the mismatch
+
+`notes/batched-bit-rows.tex`, General moment condition, gives child width
+`t_i*floor(e/m)`, not `floor(t_i*e/m)`. For e=mq+a, 0<=a<m, their difference is
+floor(t_i*a/m), which can be positive. For m=3,t_i=2,e=5 the widths are 2 and 3.
+Equality for every e holds exactly for t_i=1 within 1<=t_i<m: when t_i>1,
+a=m-1 gives difference t_i-1. No raw mixed-rank substitution is made here.
+
+`research/kappa-rebuild/architecture/FINITE-PRECOMPILATION.md`, Section 6,
+instead makes every paid leaf rank one in a fixed compiled rank-N word. Under
+tensor multiplicity f each becomes a rank-f call and the strict ratio is 1/N.
+Combining this with the integer-width law gives exactly
+
+    e = Nq+r, 0<=r<N; each of the P paid calls has width q=floor(e/N).
+
+Here N and the paid-list length P are fixed finite constants of the compiled
+word. This note does not materialize the enormous selected final word or prove
+its compiler/owner semantics. It supplies a uniformly parameterized literal
+controller for this exact final rank-one law.
+
+The complex note's Stopping and weighted-tree bounds stops when e<d^beta.
+For integer e this is equivalent to e<L with L=ceil(d^beta). L is a root
+quantity, unchanged inside descendants. The new program receives L as a
+positive unary input, and stops when e<max(N,L). Thus it agrees with the stated
+complex stopping law when L>=N; small roots requiring individual processing
+remain the source's fixed finite fallback. Generating L, or evaluating its
+rational-power predicate from the actual binary root inputs, is not free and
+is not implemented here.
+
+## 2. Literal four-tape extension
+
+`selected_control.py` uses the frozen earlier Builder and interpreter from
+`controller_reference.py`, plus a read-only CUTOFF tape. N and P are compile-time
+parameters. There are exactly
+
+    30N+42+P(69+3N)
+
+instruction locations, P+4 symbols and four fixed tapes, independent of e or L.
+The N=3,P=2 example has 288 locations. No input-sized program or alphabet is
+constructed at run time.
+
+The old finite probe first detects e<N. Otherwise the comparator advances
+WIDTH and CUTOFF in lockstep. It reads CUTOFF first: a blank means e>=L,
+including equality; if CUTOFF is nonblank and WIDTH is blank, e<L. At either
+exit it rewinds both heads. Each comparison step reads two symbols, moves two
+heads and jumps, five transitions. If k=min(e,L), the two rewinds cost 6k+6.
+Including terminal probes and the E/L edge and successor, the comparator costs
+at most 11k+10. It never visits beyond k on either tape, never writes CUTOFF,
+and returns both heads to their supplied markers. L can greatly exceed e;
+comparison does not scan the entire cutoff in that case.
+
+Internal entries emit E and then B_r, where r=e mod N. A separate finite
+remainder-state scan proves r by the invariant current_state=k mod N after k
+unary symbols, rewinds WIDTH and emits the hook. It costs 6e+7 transitions.
+The P child calls use the old rank-one quotient machine, with the same tagged
+parent-width push/pop and exact restoration. After the last return, a second
+scan emits A_r, then X completes the node. Recomputing r avoids parking another
+input-dependent descriptor. Both remainder scans see the restored parent e.
+
+B_0/A_0 are explicit zero-remainder hooks: the payload consumer must skip the
+remainder action, rather than interpreting zero as a positive recursive call.
+All hook dispatch transitions are included in the controller invoice. Leaves
+emit L,X and no remainder hooks. Arbitrary initial ancestors and all four
+heads/cell contents are restored under the same valid-input convention.
+
+The emitted hooks are labelled finite-control edges, not a materialized event
+list. A consumer must preserve these descriptor tapes on return and pay its
+own execution. Python traces and snapshots remain verifier observations.
+
+## 3. Control time and retained backing
+
+Parent-width park/return cost remains at most 48e+38 per child, excluding child
+execution. The original N-probe costs at most 6e+7; the added comparison at
+most 11e+10; both remainder scans total 12e+14. Counting node completion and
+the root's final halt gives the conservative complete bound
+
+    T_control <= 200(P+1) * sum_v e_v.
+
+This includes every comparison rewind, remainder scan, continuation tag and
+RETURN. The constant depends on the fixed number of paid sites P.
+
+All child widths are floor(e/N), hence at most e/N and strictly positive at an
+internal node. The original three-tape retained interval argument applies with
+rho=1/N. CUTOFF adds visits to only min(e_root,L)+2 cells. If D is maximum depth,
+
+    S <= K0+2(e+2)+e/(1-1/N)+D+2+min(e,L)+2
+      <= K0+(4+N/(N-1))*e+8.
+
+K0 includes the entire supplied cutoff and all preexisting erased backing.
+Consequently this is a bound on new historical interval usage plus entry
+backing; it does not hide a huge supplied L in a supposedly O(e) input bound.
+Completed siblings reuse the same origins, so the bound does not accumulate
+over the whole tree. No ancestor prefix below the entry delimiter is scanned.
+
+When L>=N, the exact number of descents is zero for e<L, otherwise
+1+floor(log_N(e/L)); the operational definition is repeated integer division
+until below L, with no real logarithm routine. This follows from
+floor(floor(e/N^j)/N)=floor(e/N^(j+1)) and
+floor(e/N^j)>=L iff e>=L*N^j. Earlier stopping never requires more row stock than
+the source's cutoff-N depth bound. This does not itself generate that stock.
+
+## 4. Remainders and conditional node-volume composition
+
+The complex note's Integer axis counts processes the r<N removed kernels
+individually before the N equal q-axis slots. Removed axes remain completed
+spectators. Tensor maps on the disjoint parts commute, so B_r is the appropriate
+pre-hook; its A_r consumer may be a no-op. The bit note's Bit interchange with
+a remainder instead exchanges/gathers the two high r-digit parts before the
+main circuit and ungathers after it. Its consumer must implement both B_r
+and A_r with the correct whole-field layout. A pre-hook alone is insufficient
+for that retained BIT interface.
+
+The compiled word's ordinary operations between paid calls must also remain
+chronological. Attach its initial scalar/frame segment to the B_r consumer
+(after remainder preparation), and each following segment to U_i while parent
+WIDTH is restored, before the next descent or A_r. Thus the event interface
+does not require pretending the paid children are consecutive with no scalar
+work between them. Source binding of these segments and their charges remains
+an explicit consumer obligation.
+
+These are source-prescribed consumers, not newly implemented kernels. If their
+complete transition costs are bounded by C_pre(N)*V and C_post(N)*V, including
+all r individual operations, and their exact frame/ownership contracts hold,
+then their combined local bill is a fixed multiple of V. The r axes are not
+additional recursive children or artificially tiny stopping leaves. For r=0
+these payload actions are skipped, with the controller's finite hooks paid.
+
+Under the selected review Section 5 complete-root-factor invariant, at least
+one complete D-bit factor per node gives V_v>=2^D>=D>=e_v. The full controller
+bill is then at most 200(P+1)*sum_v V_v. Combining it with admitted remainder,
+frame and scalar fees gives the conditional node recurrence
+
+    T(V,e) <= P*T(V/W, floor(e/N)) + C_template*V
+
+above the supplied cutoff, and the existing separately paid leaf routine below.
+C_template includes controller and both consumer constants; it is not an old
+numeric cap. Each child receives V/W only if the actual complete-row/stock
+interface supplies that volume. This controller does not prove the grants,
+remainder operators, compiler, native endpoints or numerical/analytic bounds.
+
+For the complex stopping source, if d^beta>=2N, every nonroot stopping leaf
+arises from a parent e>=d^beta and has width floor(e/N)>=d^beta/(2N).
+The bounded r<N remainder actions stay local hooks, so they do not create
+extra width-one stopping leaves that would violate that guard interface.
+This is the source's quantitative boundary instantiated at the compiled N;
+the precision/guard theorem itself remains retained.
+
+## 5. Verification, novelty and remaining work
+
+The verifier observes both event labels and actual unary widths. It checks the
+exact cutoff equality, repeated paid sites, pre/post remainders (including
+zero), restoration and retained intervals. A separate dense CPU corroborates
+translated examples. Controls mutate the cutoff equality branch, a cutoff
+head move, post-remainder identity and omission; a raw-mixed rounding fixture
+prevents treating the two floor laws as identical. Universal claims are the
+written loop/stack inductions, not extrapolations of these finite executions.
+
+The extension's new work is the actual rank-one source-law/cutoff/remainder
+connection. It does not repeat #5158's fixed-bank recursion or #6719's much
+richer delayed-cover binary-root/grant/payload program. It adds no selected
+kappa and discharges none of the five full framework assumptions.
+
+Next steps: supply actual binary root cutoff/width production; bind the selected
+P,N and any remainder/leaf adapters to a final occurrence emitter; join literal
+payload consumers to the hooks with exact tape frame and step contracts. Those
+remain substantive obligations, not completed consequences of this control proof.
diff --git a/research/selected-rank-control/SOURCES.json b/research/selected-rank-control/SOURCES.json
new file mode 100644
index 0000000000..06f299b883
--- /dev/null
+++ b/research/selected-rank-control/SOURCES.json
@@ -0,0 +1,143 @@
+{
+  "base": "e54523517d0f03e58352e647c403a5af3e525a57",
+  "selected_kappa": "0.00363005817",
+  "references": [
+    {
+      "path": "research/fixed-bank-recursive-row-caller/PROOF.md",
+      "size": 8089,
+      "git_blob": "be4fa4709e75d43f0ba6b0ff95eed13f4cb64f87",
+      "sha256": "2e6af9844d4a28f669bcea190a9e296a323664e823bf5a354d48d498efbb1638",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "e54523517d0f03e58352e647c403a5af3e525a57",
+      "role": "credited reference text, not imported executable"
+    },
+    {
+      "path": "research/fixed-bank-recursive-row-caller/README.md",
+      "size": 1837,
+      "git_blob": "de9f95fca7d54f13fbdb2625d101274baba9a41d",
+      "sha256": "060897cdf1a319eb313542c8cf222ae048e9e353063322ef7e99a2dddcce8662",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "e54523517d0f03e58352e647c403a5af3e525a57",
+      "role": "credited reference text, not imported executable"
+    },
+    {
+      "path": "research/literal-complete-row-parking-caller/PROOF.md",
+      "size": 6812,
+      "git_blob": "c80c6be99447a3e242120fff186662daa9b250ba",
+      "sha256": "c076d8638ea543f209b6c1438315dc25e39097c4b516f4a7a24d3fdaa1c4b38c",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "e54523517d0f03e58352e647c403a5af3e525a57",
+      "role": "credited reference text, not imported executable"
+    },
+    {
+      "path": "research/literal-complete-row-parking-caller/README.md",
+      "size": 1465,
+      "git_blob": "d7bea01a284934c005f8bd0a05159642d262a777",
+      "sha256": "6d3df91a1c820ec01531e193f4a3f326546179f2ddddc9c7d162d923ff774ff2",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "e54523517d0f03e58352e647c403a5af3e525a57",
+      "role": "credited reference text, not imported executable"
+    },
+    {
+      "path": "docs/research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md",
+      "size": 25533,
+      "git_blob": "3dd1af2285e597676725e85ad4f65e7ad326d695",
+      "sha256": "4501502c2ceb9759b20372435fe4beb51082c5a5e2910c1fd5dbe6edca415055",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "e54523517d0f03e58352e647c403a5af3e525a57",
+      "role": "credited reference text, not imported executable"
+    },
+    {
+      "path": "notes/batched-bit-rows.tex",
+      "size": 6092,
+      "git_blob": "cbaa8cb42cad1e714a1d24b16ab160ae6eaf60c9",
+      "sha256": "ef72c0ead19373cbc19c8a3aacb44dd0f75353ee5f4d055f775a986a4878022c",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "e54523517d0f03e58352e647c403a5af3e525a57",
+      "role": "source law and cutoff/remainder specification; no imported executable"
+    },
+    {
+      "path": "notes/batched-complex-rows.tex",
+      "size": 6085,
+      "git_blob": "e13bd96eb29bdc6526f10dc32e0a146bc17848a4",
+      "sha256": "64c70926a8705874f1c9b42a2f703e42cad4e90f927f544458cfdf729540236c",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "e54523517d0f03e58352e647c403a5af3e525a57",
+      "role": "source law and cutoff/remainder specification; no imported executable"
+    },
+    {
+      "path": "research/kappa-rebuild/architecture/FINITE-PRECOMPILATION.md",
+      "size": 15898,
+      "git_blob": "4badb40f0919c515823cb07e44c6470d4d6469ca",
+      "sha256": "4cb32f6b8e388ecf6ed41b5bbdeeb4539cb40c8424f194974afea58f7e0921e8",
+      "repository": "CrocSwap/integer-mult-bounds",
+      "commit": "e54523517d0f03e58352e647c403a5af3e525a57",
+      "role": "source law and cutoff/remainder specification; no imported executable"
+    }
+  ],
+  "other_overlap": [
+    {
+      "pr": 6719,
+      "head": "e4e52d6ba2c805fa78bb57778c3b7bbc064edba5",
+      "scope": "supplied unary depth; generated delayed-cover grants and literal payload routing"
+    },
+    {
+      "pr": 6722,
+      "head": "37c6ca0e216e19bb4a0b9f084b13923f67c3db9d",
+      "scope": "source-pinned isolated producer/router composition review"
+    },
+    {
+      "pr": 7150,
+      "head": "107ea2e77dcf44d50343eb818b5b14e1f537c8c7",
+      "scope": "primitive wrapper finite microcontrol; not recursion shape"
+    },
+    {
+      "pr": 7151,
+      "head": "774e7890e9e1379d084e711c53937cc30c8bc434",
+      "scope": "stratified owned reserves; abstract backing coefficients"
+    }
+  ],
+  "retrieval_note": "Local reference copies had one retrieval-added final newline. Raw length and Git blob were recovered and authenticated against pinned Git trees before hashing; none is an executable dependency.",
+  "package_path": "research/selected-rank-control",
+  "frozen_artifacts": [
+    {
+      "file": "controller_reference.py",
+      "frozen_origin": "work/tape_dispatch/package/controller.py",
+      "sha256": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73",
+      "change": "byte-identical"
+    },
+    {
+      "file": "selected_control.py",
+      "frozen_origin": "work/tape_binding/selected_control.py",
+      "sha256": "1c977e9f4864d338f874aa4943d9f3422d964c3ab0cc2f877d9bc4c2d9e20237",
+      "change": "byte-identical"
+    },
+    {
+      "file": "verify_selected.py",
+      "frozen_origin": "work/tape_binding/verify_selected.py",
+      "sha256": "e2adab4be25b357578993f10e8952c26ea9ee1a9f66fb6f26a1b341709d4e2b0",
+      "change": "byte-identical"
+    },
+    {
+      "file": "GENERAL-CONTROL-PROOF.md",
+      "frozen_origin": "work/tape_dispatch/package/PROOF.md",
+      "sha256": "f9b9d781d313b1cba46cfa3cc39be149c063863b2c6f5e4b17f085b07b4ec4f8",
+      "change": "byte-identical"
+    },
+    {
+      "file": "SOURCE-BINDING.md",
+      "frozen_origin": "work/tape_binding/SOURCE-BINDING.md",
+      "sha256": "48ba45eb71df262db7384aa7a8003d9cd2801348c486948cab431528363bf6e5",
+      "change": "byte-identical"
+    },
+    {
+      "file": "verify_general.py",
+      "frozen_origin": "work/tape_dispatch/package/verify.py",
+      "original_sha256": "20d209d3be48c121472225669d5cab096737d62a5c467c5093ddf3c6a8ed3aae",
+      "sha256": "b7a290ab51cc83a2344a205d2a2f63af89ed1acc5a521def65a000acb36198e3",
+      "change": "only controller -> controller_reference in one import; filename adapted"
+    }
+  ],
+  "external_executable_dependencies": [],
+  "source_boundary": "Controller and source-law/cutoff/remainder specialization only. Selected actual final template and payload consumers are not materialized."
+}
diff --git a/research/selected-rank-control/VALIDATION.json b/research/selected-rank-control/VALIDATION.json
new file mode 100644
index 0000000000..25a4cb3e5a
--- /dev/null
+++ b/research/selected-rank-control/VALIDATION.json
@@ -0,0 +1,86 @@
+{
+  "status": "Author normal/optimized replay, root proof/integration review and separate dense CPU/address-tree review passed; final package replay passed",
+  "base": "e54523517d0f03e58352e647c403a5af3e525a57",
+  "python": "3.12.14",
+  "command": "python3 -B research/selected-rank-control/verify_all.py",
+  "normal_optimized_byte_equal": true,
+  "general_coverage": {
+    "m": "2..4",
+    "sites": "1..3",
+    "ordered_profiles": "all positive ranks below m",
+    "root_width": "1..16",
+    "cases": 896,
+    "nodes": 13540,
+    "transitions": 3469732,
+    "dense_cpu_cases": 9,
+    "negative_controls": 10
+  },
+  "selected_coverage": {
+    "N": "2..5",
+    "P": "1..3",
+    "root_width": "1..20",
+    "supplied_cutoff": "1..10",
+    "cases": 2400,
+    "nodes": 10878,
+    "transitions": 3443893,
+    "dense_cpu_cases": 8,
+    "negative_controls": 8
+  },
+  "sampling": "exhaustive Cartesian domains above; no random seed; fixed finite stopping rule",
+  "independent_proof_review": {
+    "reviewer": "orchestrator /root, separate agent",
+    "general": "passed loop, stack, time and backing proof",
+    "selected": "passed source law, cutoff, hooks, depth and leaf lower bound; exact remainder count corrected to 6e+7 / 12e+14",
+    "limitations": "Independent AI review and execution; no human or formal-kernel acceptance"
+  },
+  "freeze": "All scientific code/proofs are byte-identical to reviewed originals; generic verifier only adapts one import to controller_reference.",
+  "frozen_artifacts_checked": 6,
+  "kappa": "No new kappa; selected conditional 0.00363005817 unchanged",
+  "remaining_assumptions": [
+    "native_all_columns",
+    "owned_erasure",
+    "compiler",
+    "precision_tape",
+    "analytic_recovery"
+  ],
+  "limitations": [
+    "supplied unary root width/cutoff; no binary input adapter",
+    "no selected final word or owner manifest emitted",
+    "payload, grants and remainder consumers not implemented",
+    "no formal-kernel proof or complete native implementation"
+  ],
+  "sha256": {
+    "GENERAL-CONTROL-PROOF.md": "f9b9d781d313b1cba46cfa3cc39be149c063863b2c6f5e4b17f085b07b4ec4f8",
+    "PR-DESCRIPTION.md": "e236433dbb04e7e31891e793c27538bb4669f3b695716eb4ffcc7fa165d958fc",
+    "PR-TITLE.txt": "df1bc823594023bcdc95cd95137cdb904e90ba024a0fb49dcc99ff20584c50eb",
+    "README.md": "b98a5f8a2b8efbacd94156b21d488be528b838394db3f593cd648c9bfaa84122",
+    "REVIEW.md": "fd1a3fd6e036d38a90bcfc57cbcb33aa2b4a0a2625b277cd771e2b27aea81942",
+    "SOURCE-BINDING.md": "48ba45eb71df262db7384aa7a8003d9cd2801348c486948cab431528363bf6e5",
+    "SOURCES.json": "9f57460dcb1a85499efdb2ec34e8cd9a3d909c10d56adc8f556d868c266a3e71",
+    "controller_reference.py": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73",
+    "evidence/combined.json": "c10fbeda2dc5ccb23d1a4ec34278b41d5a4ab11d8ce6fe06a7e876d8f7664e78",
+    "evidence/general_normal.json": "37bbfb6bf338f122a0d16366579b995ab2d91faa01ec9d122799d575cc8e85c1",
+    "evidence/general_optimized.json": "37bbfb6bf338f122a0d16366579b995ab2d91faa01ec9d122799d575cc8e85c1",
+    "evidence/independent.json": "cbb8036301b8b0f29a30c0431777ebf972f811f96669584dd2f7627d795f885e",
+    "evidence/root-replay.json": "c10fbeda2dc5ccb23d1a4ec34278b41d5a4ab11d8ce6fe06a7e876d8f7664e78",
+    "evidence/selected_normal.json": "931ea5c21ad379465b45b79976e53ed3d464aa9eec93f2f489bf047eabff4e86",
+    "evidence/selected_optimized.json": "931ea5c21ad379465b45b79976e53ed3d464aa9eec93f2f489bf047eabff4e86",
+    "independent_check.py": "442d53b89c59eea574ef65c6df7da91b08727ae2d7296581710ef90c85a5650a",
+    "selected_control.py": "1c977e9f4864d338f874aa4943d9f3422d964c3ab0cc2f877d9bc4c2d9e20237",
+    "verify_all.py": "5a8f1e3e0e26ac773583bee216a0f78fa3abf2f6596ea0eb5a14d6f35da7edf6",
+    "verify_general.py": "b7a290ab51cc83a2344a205d2a2f63af89ed1acc5a521def65a000acb36198e3",
+    "verify_selected.py": "e2adab4be25b357578993f10e8952c26ea9ee1a9f66fb6f26a1b341709d4e2b0"
+  },
+  "independent_executable_review": {
+    "reviewer": "separate compiler/source-index worker",
+    "checker": "independent_check.py",
+    "receipt": "evidence/independent.json",
+    "cases": 125,
+    "nodes": 837,
+    "transitions": 488423,
+    "exact_remainder_scans": 556,
+    "negative_controls": 3,
+    "root_replayed": true
+  },
+  "root_replay": "evidence/root-replay.json; byte-content parsed equal to author combined receipt"
+}
diff --git a/research/selected-rank-control/controller_reference.py b/research/selected-rank-control/controller_reference.py
new file mode 100644
index 0000000000..3ab6d0361f
--- /dev/null
+++ b/research/selected-rank-control/controller_reference.py
@@ -0,0 +1,112 @@
+"""Finite three-tape online rank-recursion control; Apache-2.0.
+Only PC and local symbols affect execution. Metrics/event logs are observers.
+"""
+from dataclasses import dataclass, field
+BLANK, ONE, MARK = '_', '1', '|'
+WIDTH, CHILD, STACK = range(3)
+
+class Builder:
+    def __init__(self): self.code, self.labels, self.serial = [], {}, 0
+    def mark(self,n):
+        if n in self.labels: raise ValueError('duplicate label')
+        self.labels[n]=len(self.code)
+    def op(self,*x): self.code.append(x)
+    def rewind(self,t,symbols):
+        self.serial+=1; loop=f'rw{self.serial}'; done=loop+'done'
+        self.op('move',t,-1); self.mark(loop)
+        self.op('read',t,{s:loop+'step' for s in symbols}|{MARK:done})
+        self.mark(loop+'step'); self.op('move',t,-1); self.op('goto',loop)
+        self.mark(done); self.op('move',t,1)
+    def finish(self,alphabet):
+        result=[]
+        for op,*a in self.code:
+            if op=='goto': a[0]=self.labels[a[0]]
+            elif op=='read': a[1]={s:self.labels[n] for s,n in a[1].items()}
+            result.append((op,*a))
+        return tuple(result),tuple(alphabet)
+
+def compile_controller(m,ranks):
+    """Parameters are compile-time constants, absent from run-time state."""
+    if type(m) is not int or m<2 or not ranks: raise ValueError('bad fixed profile')
+    if any(type(r) is not int or not 1<=r<m for r in ranks): raise ValueError('rank range')
+    ranks=tuple(ranks); tags=tuple(f't{i}' for i in range(len(ranks)))
+    a=Builder(); a.mark('enter'); a.op('read',WIDTH,{ONE:'probe0'})
+    for k in range(m):
+        a.mark(f'probe{k}'); a.op('read',WIDTH,{ONE:f'advance{k}',BLANK:f'leaf{k}'})
+        a.mark(f'advance{k}'); a.op('move',WIDTH,1)
+        a.op('goto',f'probe{k+1}' if k+1<m else 'internal_rewind')
+        a.mark(f'leaf{k}'); a.rewind(WIDTH,(ONE,)); a.op('emit','L'); a.op('goto','complete')
+    a.mark('internal_rewind'); a.rewind(WIDTH,(ONE,)); a.op('emit','E'); a.op('goto','child0')
+    for i,r in enumerate(ranks):
+        a.mark(f'child{i}'); a.op('goto',f'build{i}_0')
+        for rem in range(m):
+            a.mark(f'build{i}_{rem}')
+            a.op('read',WIDTH,{ONE:f'build{i}_{rem}bit',BLANK:f'built{i}'})
+            a.mark(f'build{i}_{rem}bit'); quotient,nxt=divmod(rem+r,m)
+            if quotient: a.op('write',CHILD,ONE); a.op('move',CHILD,1)
+            a.op('move',WIDTH,1); a.op('goto',f'build{i}_{nxt}')
+        a.mark(f'built{i}'); a.rewind(WIDTH,(ONE,)); a.rewind(CHILD,(ONE,))
+        a.mark(f'push{i}'); a.op('read',WIDTH,{ONE:f'push{i}bit',BLANK:f'pushed{i}'})
+        a.mark(f'push{i}bit'); a.op('write',STACK,ONE); a.op('write',WIDTH,BLANK)
+        a.op('move',WIDTH,1); a.op('move',STACK,1); a.op('goto',f'push{i}')
+        a.mark(f'pushed{i}'); a.op('write',STACK,tags[i]); a.op('move',STACK,1); a.rewind(WIDTH,(BLANK,))
+        a.mark(f'transfer{i}'); a.op('read',CHILD,{ONE:f'transfer{i}bit',BLANK:f'transferred{i}'})
+        a.mark(f'transfer{i}bit'); a.op('write',WIDTH,ONE); a.op('write',CHILD,BLANK)
+        a.op('move',WIDTH,1); a.op('move',CHILD,1); a.op('goto',f'transfer{i}')
+        a.mark(f'transferred{i}'); a.rewind(WIDTH,(ONE,)); a.rewind(CHILD,(BLANK,))
+        a.op('emit',f'D{i}'); a.op('goto','enter')
+    a.mark('complete'); a.op('emit','X'); a.op('move',STACK,-1)
+    a.op('read',STACK,{MARK:'root_done',**{t:f'return{i}' for i,t in enumerate(tags)}})
+    a.mark('root_done'); a.op('move',STACK,1); a.op('halt')
+    for i in range(len(ranks)):
+        a.mark(f'return{i}'); a.op('write',STACK,BLANK); a.op('move',STACK,-1)
+        a.mark(f'erase{i}'); a.op('read',WIDTH,{ONE:f'erase{i}bit',BLANK:f'erased{i}'})
+        a.mark(f'erase{i}bit'); a.op('write',WIDTH,BLANK); a.op('move',WIDTH,1); a.op('goto',f'erase{i}')
+        a.mark(f'erased{i}'); a.rewind(WIDTH,(BLANK,))
+        a.mark(f'pop{i}'); a.op('read',STACK,{ONE:f'pop{i}bit',MARK:f'popped{i}',**{t:f'popped{i}' for t in tags}})
+        a.mark(f'pop{i}bit'); a.op('write',WIDTH,ONE); a.op('write',STACK,BLANK)
+        a.op('move',WIDTH,1); a.op('move',STACK,-1); a.op('goto',f'pop{i}')
+        a.mark(f'popped{i}'); a.op('move',STACK,1); a.rewind(WIDTH,(ONE,)); a.op('emit',f'U{i}')
+        a.op('goto',f'child{i+1}' if i+1<len(ranks) else 'complete')
+    return a.finish((BLANK,'0',ONE,MARK,*tags))
+
+@dataclass
+class Tape:
+    cells:dict
+    head:int
+    low:int=field(init=False)
+    high:int=field(init=False)
+    def __post_init__(self): self.low=self.high=self.head
+    def read(self): return self.cells.get(self.head,BLANK)
+    def write(self,s):
+        if s==BLANK: self.cells.pop(self.head,None)
+        else: self.cells[self.head]=s
+    def move(self,d):
+        self.head+=d; self.low=min(self.low,self.head); self.high=max(self.high,self.head)
+
+class Machine:
+    def __init__(self,code,tapes):
+        self.code,self.tapes=code,tapes; self.pc=self.steps=0; self.events=[]; self.halted=False
+    def step(self):
+        op,*a=self.code[self.pc]; self.steps+=1; self.pc+=1
+        if op=='read':
+            s=self.tapes[a[0]].read()
+            if s not in a[1]: raise ValueError('invalid scanned symbol')
+            self.pc=a[1][s]
+        elif op=='write': self.tapes[a[0]].write(a[1])
+        elif op=='move': self.tapes[a[0]].move(a[1])
+        elif op=='goto': self.pc=a[0]
+        elif op=='emit': self.events.append(a[0])
+        elif op=='halt': self.halted=True
+        else: raise ValueError('invalid opcode')
+    def run(self,budget=10_000_000):
+        while not self.halted:
+            if self.steps>=budget: raise ValueError('finite verifier budget')
+            self.step()
+        return self
+
+def initial_tapes(width,origins=(0,0,0),ancestor=('0','1','t0','_','|','0')):
+    if width<1: raise ValueError('positive width')
+    u,c,p=origins
+    return [Tape({u-1:MARK,**{u+i:ONE for i in range(width)}},u),Tape({c-1:MARK},c),
+            Tape({p-1:MARK,**{p-2-i:s for i,s in enumerate(ancestor) if s!=BLANK}},p)]
diff --git a/research/selected-rank-control/evidence/combined.json b/research/selected-rank-control/evidence/combined.json
new file mode 100644
index 0000000000..9608e62246
--- /dev/null
+++ b/research/selected-rank-control/evidence/combined.json
@@ -0,0 +1,148 @@
+{
+  "normal_optimized_byte_equal": true,
+  "receipts": {
+    "general_normal": {
+      "finite_cases": 896,
+      "formal_kernel": "not_run",
+      "independent_dense_cases": 9,
+      "kappa": "unchanged",
+      "maximum_observed_steps_over_splus1_mass": "2509/96",
+      "negative_controls": 10,
+      "nodes": 13540,
+      "selected_payload_implementation": "not_claimed",
+      "shape_blowup": [
+        {
+          "depth": 0,
+          "nodes": 1,
+          "width": 1
+        },
+        {
+          "depth": 1,
+          "nodes": 4,
+          "width": 2
+        },
+        {
+          "depth": 2,
+          "nodes": 13,
+          "width": 4
+        },
+        {
+          "depth": 3,
+          "nodes": 40,
+          "width": 8
+        },
+        {
+          "depth": 4,
+          "nodes": 121,
+          "width": 16
+        },
+        {
+          "depth": 5,
+          "nodes": 364,
+          "width": 32
+        },
+        {
+          "depth": 6,
+          "nodes": 1093,
+          "width": 64
+        },
+        {
+          "depth": 7,
+          "nodes": 3280,
+          "width": 128
+        },
+        {
+          "depth": 8,
+          "nodes": 9841,
+          "width": 256
+        }
+      ],
+      "status": "PASS_ONLINE_RANK_CONTROL",
+      "transitions": 3469732
+    },
+    "general_optimized": {
+      "finite_cases": 896,
+      "formal_kernel": "not_run",
+      "independent_dense_cases": 9,
+      "kappa": "unchanged",
+      "maximum_observed_steps_over_splus1_mass": "2509/96",
+      "negative_controls": 10,
+      "nodes": 13540,
+      "selected_payload_implementation": "not_claimed",
+      "shape_blowup": [
+        {
+          "depth": 0,
+          "nodes": 1,
+          "width": 1
+        },
+        {
+          "depth": 1,
+          "nodes": 4,
+          "width": 2
+        },
+        {
+          "depth": 2,
+          "nodes": 13,
+          "width": 4
+        },
+        {
+          "depth": 3,
+          "nodes": 40,
+          "width": 8
+        },
+        {
+          "depth": 4,
+          "nodes": 121,
+          "width": 16
+        },
+        {
+          "depth": 5,
+          "nodes": 364,
+          "width": 32
+        },
+        {
+          "depth": 6,
+          "nodes": 1093,
+          "width": 64
+        },
+        {
+          "depth": 7,
+          "nodes": 3280,
+          "width": 128
+        },
+        {
+          "depth": 8,
+          "nodes": 9841,
+          "width": 256
+        }
+      ],
+      "status": "PASS_ONLINE_RANK_CONTROL",
+      "transitions": 3469732
+    },
+    "selected_normal": {
+      "cases": 2400,
+      "controls": 8,
+      "cutoff": "supplied input; production not claimed",
+      "independent_dense_cases": 8,
+      "kappa": "unchanged",
+      "m3_sites2_instructions": 288,
+      "nodes": 10878,
+      "remainder_zero": "explicit B0/A0 hooks; consumer must skip payload work",
+      "status": "PASS_SELECTED_UNIFORM_CONTROL",
+      "transitions": 3443893
+    },
+    "selected_optimized": {
+      "cases": 2400,
+      "controls": 8,
+      "cutoff": "supplied input; production not claimed",
+      "independent_dense_cases": 8,
+      "kappa": "unchanged",
+      "m3_sites2_instructions": 288,
+      "nodes": 10878,
+      "remainder_zero": "explicit B0/A0 hooks; consumer must skip payload work",
+      "status": "PASS_SELECTED_UNIFORM_CONTROL",
+      "transitions": 3443893
+    }
+  },
+  "status": "PASS_SELECTED_RANK_CONTROL_PACKAGE"
+}
diff --git a/research/selected-rank-control/evidence/general_normal.json b/research/selected-rank-control/evidence/general_normal.json
new file mode 100644
index 0000000000..e109949708
--- /dev/null
+++ b/research/selected-rank-control/evidence/general_normal.json
@@ -0,0 +1,59 @@
+{
+  "finite_cases": 896,
+  "formal_kernel": "not_run",
+  "independent_dense_cases": 9,
+  "kappa": "unchanged",
+  "maximum_observed_steps_over_splus1_mass": "2509/96",
+  "negative_controls": 10,
+  "nodes": 13540,
+  "selected_payload_implementation": "not_claimed",
+  "shape_blowup": [
+    {
+      "depth": 0,
+      "nodes": 1,
+      "width": 1
+    },
+    {
+      "depth": 1,
+      "nodes": 4,
+      "width": 2
+    },
+    {
+      "depth": 2,
+      "nodes": 13,
+      "width": 4
+    },
+    {
+      "depth": 3,
+      "nodes": 40,
+      "width": 8
+    },
+    {
+      "depth": 4,
+      "nodes": 121,
+      "width": 16
+    },
+    {
+      "depth": 5,
+      "nodes": 364,
+      "width": 32
+    },
+    {
+      "depth": 6,
+      "nodes": 1093,
+      "width": 64
+    },
+    {
+      "depth": 7,
+      "nodes": 3280,
+      "width": 128
+    },
+    {
+      "depth": 8,
+      "nodes": 9841,
+      "width": 256
+    }
+  ],
+  "status": "PASS_ONLINE_RANK_CONTROL",
+  "transitions": 3469732
+}
diff --git a/research/selected-rank-control/evidence/general_optimized.json b/research/selected-rank-control/evidence/general_optimized.json
new file mode 100644
index 0000000000..e109949708
--- /dev/null
+++ b/research/selected-rank-control/evidence/general_optimized.json
@@ -0,0 +1,59 @@
+{
+  "finite_cases": 896,
+  "formal_kernel": "not_run",
+  "independent_dense_cases": 9,
+  "kappa": "unchanged",
+  "maximum_observed_steps_over_splus1_mass": "2509/96",
+  "negative_controls": 10,
+  "nodes": 13540,
+  "selected_payload_implementation": "not_claimed",
+  "shape_blowup": [
+    {
+      "depth": 0,
+      "nodes": 1,
+      "width": 1
+    },
+    {
+      "depth": 1,
+      "nodes": 4,
+      "width": 2
+    },
+    {
+      "depth": 2,
+      "nodes": 13,
+      "width": 4
+    },
+    {
+      "depth": 3,
+      "nodes": 40,
+      "width": 8
+    },
+    {
+      "depth": 4,
+      "nodes": 121,
+      "width": 16
+    },
+    {
+      "depth": 5,
+      "nodes": 364,
+      "width": 32
+    },
+    {
+      "depth": 6,
+      "nodes": 1093,
+      "width": 64
+    },
+    {
+      "depth": 7,
+      "nodes": 3280,
+      "width": 128
+    },
+    {
+      "depth": 8,
+      "nodes": 9841,
+      "width": 256
+    }
+  ],
+  "status": "PASS_ONLINE_RANK_CONTROL",
+  "transitions": 3469732
+}
diff --git a/research/selected-rank-control/evidence/independent.json b/research/selected-rank-control/evidence/independent.json
new file mode 100644
index 0000000000..605794cc21
--- /dev/null
+++ b/research/selected-rank-control/evidence/independent.json
@@ -0,0 +1,3021 @@
+{
+  "status": "PASS",
+  "method": "separate dense CPU and materialized address-tree contour",
+  "cases": 125,
+  "nodes": 837,
+  "events": 3654,
+  "transitions": 488423,
+  "exact_remainder_scans": 556,
+  "negative_controls": [
+    "post remainder label changed",
+    "doubled quotient output",
+    "cutoff equality treated as leaf"
+  ],
+  "pins": {
+    "selected_control.py": "1c977e9f4864d338f874aa4943d9f3422d964c3ab0cc2f877d9bc4c2d9e20237",
+    "controller_reference.py": "e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73",
+    "SOURCE-BINDING.md": "48ba45eb71df262db7384aa7a8003d9cd2801348c486948cab431528363bf6e5"
+  },
+  "rows": [
+    {
+      "base": 2,
+      "sites": 1,
+      "width": 1,
+      "cutoff": 1,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 400,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "13",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 3,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 2,
+      "sites": 1,
+      "width": 1,
+      "cutoff": 2,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 400,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "13",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 4,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 2,
+      "sites": 1,
+      "width": 2,
+      "cutoff": 2,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 214,
+      "budget": 1200,
+      "width_volume": 3,
+      "depth": 1,
+      "visited_cells": 16,
+      "visited_bound": "19",
+      "cutoff_visited": 4,
+      "cutoff_input_cells": 4,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 2,
+      "sites": 1,
+      "width": 3,
+      "cutoff": 3,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 261,
+      "budget": 1600,
+      "width_volume": 4,
+      "depth": 1,
+      "visited_cells": 19,
+      "visited_bound": "24",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 2,
+      "sites": 1,
+      "width": 3,
+      "cutoff": 4,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 64,
+      "budget": 1200,
+      "width_volume": 3,
+      "depth": 0,
+      "visited_cells": 13,
+      "visited_bound": "23",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 6,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 2,
+      "sites": 1,
+      "width": 3,
+      "cutoff": 2,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 250,
+      "budget": 1600,
+      "width_volume": 4,
+      "depth": 1,
+      "visited_cells": 18,
+      "visited_bound": "23",
+      "cutoff_visited": 4,
+      "cutoff_input_cells": 4,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 2,
+      "sites": 1,
+      "width": 4,
+      "cutoff": 2,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 14,
+      "steps": 506,
+      "budget": 2800,
+      "width_volume": 7,
+      "depth": 2,
+      "visited_cells": 24,
+      "visited_bound": "28",
+      "cutoff_visited": 4,
+      "cutoff_input_cells": 4,
+      "comparisons": 2,
+      "exact_remainder_scans": 4
+    },
+    {
+      "base": 2,
+      "sites": 1,
+      "width": 5,
+      "cutoff": 3,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 392,
+      "budget": 2800,
+      "width_volume": 7,
+      "depth": 1,
+      "visited_cells": 24,
+      "visited_bound": "32",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 2,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 2,
+      "sites": 1,
+      "width": 9,
+      "cutoff": 100003,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 130,
+      "budget": 3600,
+      "width_volume": 9,
+      "depth": 0,
+      "visited_cells": 25,
+      "visited_bound": "53",
+      "cutoff_visited": 11,
+      "cutoff_input_cells": 100005,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 2,
+      "sites": 1,
+      "width": 8,
+      "cutoff": 3,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 14,
+      "steps": 851,
+      "budget": 5600,
+      "width_volume": 14,
+      "depth": 2,
+      "visited_cells": 37,
+      "visited_bound": "45",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 3,
+      "exact_remainder_scans": 4
+    },
+    {
+      "base": 2,
+      "sites": 2,
+      "width": 1,
+      "cutoff": 1,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 600,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "13",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 3,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 2,
+      "sites": 2,
+      "width": 1,
+      "cutoff": 2,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 600,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "13",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 4,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 2,
+      "sites": 2,
+      "width": 2,
+      "cutoff": 2,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 338,
+      "budget": 2400,
+      "width_volume": 4,
+      "depth": 1,
+      "visited_cells": 16,
+      "visited_bound": "19",
+      "cutoff_visited": 4,
+      "cutoff_input_cells": 4,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 2,
+      "sites": 2,
+      "width": 3,
+      "cutoff": 3,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 409,
+      "budget": 3000,
+      "width_volume": 5,
+      "depth": 1,
+      "visited_cells": 19,
+      "visited_bound": "24",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 2,
+      "sites": 2,
+      "width": 3,
+      "cutoff": 4,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 64,
+      "budget": 1800,
+      "width_volume": 3,
+      "depth": 0,
+      "visited_cells": 13,
+      "visited_bound": "23",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 6,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 2,
+      "sites": 2,
+      "width": 3,
+      "cutoff": 2,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 398,
+      "budget": 3000,
+      "width_volume": 5,
+      "depth": 1,
+      "visited_cells": 18,
+      "visited_bound": "23",
+      "cutoff_visited": 4,
+      "cutoff_input_cells": 4,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 2,
+      "sites": 2,
+      "width": 4,
+      "cutoff": 2,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 7,
+      "events": 32,
+      "steps": 1146,
+      "budget": 7200,
+      "width_volume": 12,
+      "depth": 2,
+      "visited_cells": 24,
+      "visited_bound": "28",
+      "cutoff_visited": 4,
+      "cutoff_input_cells": 4,
+      "comparisons": 3,
+      "exact_remainder_scans": 6
+    },
+    {
+      "base": 2,
+      "sites": 2,
+      "width": 5,
+      "cutoff": 3,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 647,
+      "budget": 5400,
+      "width_volume": 9,
+      "depth": 1,
+      "visited_cells": 24,
+      "visited_bound": "32",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 3,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 2,
+      "sites": 2,
+      "width": 9,
+      "cutoff": 100003,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 130,
+      "budget": 5400,
+      "width_volume": 9,
+      "depth": 0,
+      "visited_cells": 25,
+      "visited_bound": "53",
+      "cutoff_visited": 11,
+      "cutoff_input_cells": 100005,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 2,
+      "sites": 2,
+      "width": 8,
+      "cutoff": 3,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 7,
+      "events": 32,
+      "steps": 1991,
+      "budget": 14400,
+      "width_volume": 24,
+      "depth": 2,
+      "visited_cells": 37,
+      "visited_bound": "45",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 7,
+      "exact_remainder_scans": 6
+    },
+    {
+      "base": 2,
+      "sites": 3,
+      "width": 1,
+      "cutoff": 1,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 800,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "13",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 3,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 2,
+      "sites": 3,
+      "width": 1,
+      "cutoff": 2,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 800,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "13",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 4,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 2,
+      "sites": 3,
+      "width": 2,
+      "cutoff": 2,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 462,
+      "budget": 4000,
+      "width_volume": 5,
+      "depth": 1,
+      "visited_cells": 16,
+      "visited_bound": "19",
+      "cutoff_visited": 4,
+      "cutoff_input_cells": 4,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 2,
+      "sites": 3,
+      "width": 3,
+      "cutoff": 3,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 557,
+      "budget": 4800,
+      "width_volume": 6,
+      "depth": 1,
+      "visited_cells": 19,
+      "visited_bound": "24",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 2,
+      "sites": 3,
+      "width": 3,
+      "cutoff": 4,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 64,
+      "budget": 2400,
+      "width_volume": 3,
+      "depth": 0,
+      "visited_cells": 13,
+      "visited_bound": "23",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 6,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 2,
+      "sites": 3,
+      "width": 3,
+      "cutoff": 2,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 546,
+      "budget": 4800,
+      "width_volume": 6,
+      "depth": 1,
+      "visited_cells": 18,
+      "visited_bound": "23",
+      "cutoff_visited": 4,
+      "cutoff_input_cells": 4,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 2,
+      "sites": 3,
+      "width": 4,
+      "cutoff": 2,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 13,
+      "events": 58,
+      "steps": 2034,
+      "budget": 15200,
+      "width_volume": 19,
+      "depth": 2,
+      "visited_cells": 24,
+      "visited_bound": "28",
+      "cutoff_visited": 4,
+      "cutoff_input_cells": 4,
+      "comparisons": 4,
+      "exact_remainder_scans": 8
+    },
+    {
+      "base": 2,
+      "sites": 3,
+      "width": 5,
+      "cutoff": 3,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 902,
+      "budget": 8800,
+      "width_volume": 11,
+      "depth": 1,
+      "visited_cells": 24,
+      "visited_bound": "32",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 4,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 2,
+      "sites": 3,
+      "width": 9,
+      "cutoff": 100003,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 130,
+      "budget": 7200,
+      "width_volume": 9,
+      "depth": 0,
+      "visited_cells": 25,
+      "visited_bound": "53",
+      "cutoff_visited": 11,
+      "cutoff_input_cells": 100005,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 2,
+      "sites": 3,
+      "width": 8,
+      "cutoff": 3,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 13,
+      "events": 58,
+      "steps": 3593,
+      "budget": 30400,
+      "width_volume": 38,
+      "depth": 2,
+      "visited_cells": 37,
+      "visited_bound": "45",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 13,
+      "exact_remainder_scans": 8
+    },
+    {
+      "base": 3,
+      "sites": 1,
+      "width": 1,
+      "cutoff": 1,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 400,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "25/2",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 3,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 3,
+      "sites": 1,
+      "width": 2,
+      "cutoff": 3,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 24,
+      "budget": 800,
+      "width_volume": 2,
+      "depth": 0,
+      "visited_cells": 8,
+      "visited_bound": "17",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 5,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 3,
+      "sites": 1,
+      "width": 3,
+      "cutoff": 3,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 267,
+      "budget": 1600,
+      "width_volume": 4,
+      "depth": 1,
+      "visited_cells": 19,
+      "visited_bound": "45/2",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 3,
+      "sites": 1,
+      "width": 4,
+      "cutoff": 4,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 314,
+      "budget": 2000,
+      "width_volume": 5,
+      "depth": 1,
+      "visited_cells": 22,
+      "visited_bound": "27",
+      "cutoff_visited": 6,
+      "cutoff_input_cells": 6,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 3,
+      "sites": 1,
+      "width": 4,
+      "cutoff": 5,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 81,
+      "budget": 1600,
+      "width_volume": 4,
+      "depth": 0,
+      "visited_cells": 15,
+      "visited_bound": "26",
+      "cutoff_visited": 6,
+      "cutoff_input_cells": 7,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 3,
+      "sites": 1,
+      "width": 8,
+      "cutoff": 3,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 477,
+      "budget": 4000,
+      "width_volume": 10,
+      "depth": 1,
+      "visited_cells": 30,
+      "visited_bound": "40",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 3,
+      "sites": 1,
+      "width": 9,
+      "cutoff": 3,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 14,
+      "steps": 780,
+      "budget": 5200,
+      "width_volume": 13,
+      "depth": 2,
+      "visited_cells": 37,
+      "visited_bound": "89/2",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 2,
+      "exact_remainder_scans": 4
+    },
+    {
+      "base": 3,
+      "sites": 1,
+      "width": 10,
+      "cutoff": 4,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 630,
+      "budget": 5200,
+      "width_volume": 13,
+      "depth": 1,
+      "visited_cells": 36,
+      "visited_bound": "48",
+      "cutoff_visited": 6,
+      "cutoff_input_cells": 6,
+      "comparisons": 2,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 3,
+      "sites": 1,
+      "width": 14,
+      "cutoff": 100003,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 191,
+      "budget": 5600,
+      "width_volume": 14,
+      "depth": 0,
+      "visited_cells": 35,
+      "visited_bound": "71",
+      "cutoff_visited": 16,
+      "cutoff_input_cells": 100005,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 3,
+      "sites": 1,
+      "width": 12,
+      "cutoff": 4,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 14,
+      "steps": 970,
+      "budget": 6800,
+      "width_volume": 17,
+      "depth": 2,
+      "visited_cells": 46,
+      "visited_bound": "56",
+      "cutoff_visited": 6,
+      "cutoff_input_cells": 6,
+      "comparisons": 2,
+      "exact_remainder_scans": 4
+    },
+    {
+      "base": 3,
+      "sites": 2,
+      "width": 1,
+      "cutoff": 1,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 600,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "25/2",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 3,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 3,
+      "sites": 2,
+      "width": 2,
+      "cutoff": 3,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 24,
+      "budget": 1200,
+      "width_volume": 2,
+      "depth": 0,
+      "visited_cells": 8,
+      "visited_bound": "17",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 5,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 3,
+      "sites": 2,
+      "width": 3,
+      "cutoff": 3,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 415,
+      "budget": 3000,
+      "width_volume": 5,
+      "depth": 1,
+      "visited_cells": 19,
+      "visited_bound": "45/2",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 3,
+      "sites": 2,
+      "width": 4,
+      "cutoff": 4,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 486,
+      "budget": 3600,
+      "width_volume": 6,
+      "depth": 1,
+      "visited_cells": 22,
+      "visited_bound": "27",
+      "cutoff_visited": 6,
+      "cutoff_input_cells": 6,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 3,
+      "sites": 2,
+      "width": 4,
+      "cutoff": 5,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 81,
+      "budget": 2400,
+      "width_volume": 4,
+      "depth": 0,
+      "visited_cells": 15,
+      "visited_bound": "26",
+      "cutoff_visited": 6,
+      "cutoff_input_cells": 7,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 3,
+      "sites": 2,
+      "width": 8,
+      "cutoff": 3,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 775,
+      "budget": 7200,
+      "width_volume": 12,
+      "depth": 1,
+      "visited_cells": 30,
+      "visited_bound": "40",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 3,
+      "sites": 2,
+      "width": 9,
+      "cutoff": 3,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 7,
+      "events": 32,
+      "steps": 1665,
+      "budget": 11400,
+      "width_volume": 19,
+      "depth": 2,
+      "visited_cells": 37,
+      "visited_bound": "89/2",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 3,
+      "exact_remainder_scans": 6
+    },
+    {
+      "base": 3,
+      "sites": 2,
+      "width": 10,
+      "cutoff": 4,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 1046,
+      "budget": 9600,
+      "width_volume": 16,
+      "depth": 1,
+      "visited_cells": 36,
+      "visited_bound": "48",
+      "cutoff_visited": 6,
+      "cutoff_input_cells": 6,
+      "comparisons": 3,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 3,
+      "sites": 2,
+      "width": 14,
+      "cutoff": 100003,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 191,
+      "budget": 8400,
+      "width_volume": 14,
+      "depth": 0,
+      "visited_cells": 35,
+      "visited_bound": "71",
+      "cutoff_visited": 16,
+      "cutoff_input_cells": 100005,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 3,
+      "sites": 2,
+      "width": 12,
+      "cutoff": 4,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 7,
+      "events": 32,
+      "steps": 2046,
+      "budget": 14400,
+      "width_volume": 24,
+      "depth": 2,
+      "visited_cells": 46,
+      "visited_bound": "56",
+      "cutoff_visited": 6,
+      "cutoff_input_cells": 6,
+      "comparisons": 3,
+      "exact_remainder_scans": 6
+    },
+    {
+      "base": 3,
+      "sites": 3,
+      "width": 1,
+      "cutoff": 1,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 800,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "25/2",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 3,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 3,
+      "sites": 3,
+      "width": 2,
+      "cutoff": 3,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 24,
+      "budget": 1600,
+      "width_volume": 2,
+      "depth": 0,
+      "visited_cells": 8,
+      "visited_bound": "17",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 5,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 3,
+      "sites": 3,
+      "width": 3,
+      "cutoff": 3,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 563,
+      "budget": 4800,
+      "width_volume": 6,
+      "depth": 1,
+      "visited_cells": 19,
+      "visited_bound": "45/2",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 3,
+      "sites": 3,
+      "width": 4,
+      "cutoff": 4,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 658,
+      "budget": 5600,
+      "width_volume": 7,
+      "depth": 1,
+      "visited_cells": 22,
+      "visited_bound": "27",
+      "cutoff_visited": 6,
+      "cutoff_input_cells": 6,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 3,
+      "sites": 3,
+      "width": 4,
+      "cutoff": 5,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 81,
+      "budget": 3200,
+      "width_volume": 4,
+      "depth": 0,
+      "visited_cells": 15,
+      "visited_bound": "26",
+      "cutoff_visited": 6,
+      "cutoff_input_cells": 7,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 3,
+      "sites": 3,
+      "width": 8,
+      "cutoff": 3,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 1073,
+      "budget": 11200,
+      "width_volume": 14,
+      "depth": 1,
+      "visited_cells": 30,
+      "visited_bound": "40",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 3,
+      "sites": 3,
+      "width": 9,
+      "cutoff": 3,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 13,
+      "events": 58,
+      "steps": 2846,
+      "budget": 21600,
+      "width_volume": 27,
+      "depth": 2,
+      "visited_cells": 37,
+      "visited_bound": "89/2",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 4,
+      "exact_remainder_scans": 8
+    },
+    {
+      "base": 3,
+      "sites": 3,
+      "width": 10,
+      "cutoff": 4,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 1462,
+      "budget": 15200,
+      "width_volume": 19,
+      "depth": 1,
+      "visited_cells": 36,
+      "visited_bound": "48",
+      "cutoff_visited": 6,
+      "cutoff_input_cells": 6,
+      "comparisons": 4,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 3,
+      "sites": 3,
+      "width": 14,
+      "cutoff": 100003,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 191,
+      "budget": 11200,
+      "width_volume": 14,
+      "depth": 0,
+      "visited_cells": 35,
+      "visited_bound": "71",
+      "cutoff_visited": 16,
+      "cutoff_input_cells": 100005,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 3,
+      "sites": 3,
+      "width": 12,
+      "cutoff": 4,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 13,
+      "events": 58,
+      "steps": 3466,
+      "budget": 26400,
+      "width_volume": 33,
+      "depth": 2,
+      "visited_cells": 46,
+      "visited_bound": "56",
+      "cutoff_visited": 6,
+      "cutoff_input_cells": 6,
+      "comparisons": 4,
+      "exact_remainder_scans": 8
+    },
+    {
+      "base": 5,
+      "sites": 1,
+      "width": 1,
+      "cutoff": 1,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 400,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "49/4",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 3,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 5,
+      "sites": 1,
+      "width": 4,
+      "cutoff": 5,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 36,
+      "budget": 1600,
+      "width_volume": 4,
+      "depth": 0,
+      "visited_cells": 10,
+      "visited_bound": "25",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 7,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 5,
+      "sites": 1,
+      "width": 5,
+      "cutoff": 5,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 373,
+      "budget": 2400,
+      "width_volume": 6,
+      "depth": 1,
+      "visited_cells": 25,
+      "visited_bound": "121/4",
+      "cutoff_visited": 7,
+      "cutoff_input_cells": 7,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 1,
+      "width": 6,
+      "cutoff": 6,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 420,
+      "budget": 2800,
+      "width_volume": 7,
+      "depth": 1,
+      "visited_cells": 28,
+      "visited_bound": "69/2",
+      "cutoff_visited": 8,
+      "cutoff_input_cells": 8,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 1,
+      "width": 6,
+      "cutoff": 7,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 115,
+      "budget": 2400,
+      "width_volume": 6,
+      "depth": 0,
+      "visited_cells": 19,
+      "visited_bound": "67/2",
+      "cutoff_visited": 8,
+      "cutoff_input_cells": 9,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 5,
+      "sites": 1,
+      "width": 24,
+      "cutoff": 5,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 1147,
+      "budget": 11200,
+      "width_volume": 28,
+      "depth": 1,
+      "visited_cells": 66,
+      "visited_bound": "92",
+      "cutoff_visited": 7,
+      "cutoff_input_cells": 7,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 1,
+      "width": 25,
+      "cutoff": 5,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 14,
+      "steps": 1544,
+      "budget": 12400,
+      "width_volume": 31,
+      "depth": 2,
+      "visited_cells": 75,
+      "visited_bound": "385/4",
+      "cutoff_visited": 7,
+      "cutoff_input_cells": 7,
+      "comparisons": 2,
+      "exact_remainder_scans": 4
+    },
+    {
+      "base": 5,
+      "sites": 1,
+      "width": 26,
+      "cutoff": 6,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 1322,
+      "budget": 12400,
+      "width_volume": 31,
+      "depth": 1,
+      "visited_cells": 72,
+      "visited_bound": "199/2",
+      "cutoff_visited": 8,
+      "cutoff_input_cells": 8,
+      "comparisons": 2,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 1,
+      "width": 24,
+      "cutoff": 100003,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 313,
+      "budget": 9600,
+      "width_volume": 24,
+      "depth": 0,
+      "visited_cells": 55,
+      "visited_bound": "110",
+      "cutoff_visited": 26,
+      "cutoff_input_cells": 100005,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 5,
+      "sites": 1,
+      "width": 20,
+      "cutoff": 6,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 1014,
+      "budget": 9600,
+      "width_volume": 24,
+      "depth": 1,
+      "visited_cells": 59,
+      "visited_bound": "80",
+      "cutoff_visited": 8,
+      "cutoff_input_cells": 8,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 2,
+      "width": 1,
+      "cutoff": 1,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 600,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "49/4",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 3,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 5,
+      "sites": 2,
+      "width": 4,
+      "cutoff": 5,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 36,
+      "budget": 2400,
+      "width_volume": 4,
+      "depth": 0,
+      "visited_cells": 10,
+      "visited_bound": "25",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 7,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 5,
+      "sites": 2,
+      "width": 5,
+      "cutoff": 5,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 569,
+      "budget": 4200,
+      "width_volume": 7,
+      "depth": 1,
+      "visited_cells": 25,
+      "visited_bound": "121/4",
+      "cutoff_visited": 7,
+      "cutoff_input_cells": 7,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 2,
+      "width": 6,
+      "cutoff": 6,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 640,
+      "budget": 4800,
+      "width_volume": 8,
+      "depth": 1,
+      "visited_cells": 28,
+      "visited_bound": "69/2",
+      "cutoff_visited": 8,
+      "cutoff_input_cells": 8,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 2,
+      "width": 6,
+      "cutoff": 7,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 115,
+      "budget": 3600,
+      "width_volume": 6,
+      "depth": 0,
+      "visited_cells": 19,
+      "visited_bound": "67/2",
+      "cutoff_visited": 8,
+      "cutoff_input_cells": 9,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 5,
+      "sites": 2,
+      "width": 24,
+      "cutoff": 5,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 1889,
+      "budget": 19200,
+      "width_volume": 32,
+      "depth": 1,
+      "visited_cells": 66,
+      "visited_bound": "92",
+      "cutoff_visited": 7,
+      "cutoff_input_cells": 7,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 2,
+      "width": 25,
+      "cutoff": 5,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 7,
+      "events": 32,
+      "steps": 3063,
+      "budget": 23400,
+      "width_volume": 39,
+      "depth": 2,
+      "visited_cells": 75,
+      "visited_bound": "385/4",
+      "cutoff_visited": 7,
+      "cutoff_input_cells": 7,
+      "comparisons": 3,
+      "exact_remainder_scans": 6
+    },
+    {
+      "base": 5,
+      "sites": 2,
+      "width": 26,
+      "cutoff": 6,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 2204,
+      "budget": 21600,
+      "width_volume": 36,
+      "depth": 1,
+      "visited_cells": 72,
+      "visited_bound": "199/2",
+      "cutoff_visited": 8,
+      "cutoff_input_cells": 8,
+      "comparisons": 3,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 2,
+      "width": 24,
+      "cutoff": 100003,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 313,
+      "budget": 14400,
+      "width_volume": 24,
+      "depth": 0,
+      "visited_cells": 55,
+      "visited_bound": "110",
+      "cutoff_visited": 26,
+      "cutoff_input_cells": 100005,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 5,
+      "sites": 2,
+      "width": 20,
+      "cutoff": 6,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 1660,
+      "budget": 16800,
+      "width_volume": 28,
+      "depth": 1,
+      "visited_cells": 59,
+      "visited_bound": "80",
+      "cutoff_visited": 8,
+      "cutoff_input_cells": 8,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 3,
+      "width": 1,
+      "cutoff": 1,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 800,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "49/4",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 3,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 5,
+      "sites": 3,
+      "width": 4,
+      "cutoff": 5,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 36,
+      "budget": 3200,
+      "width_volume": 4,
+      "depth": 0,
+      "visited_cells": 10,
+      "visited_bound": "25",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 7,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 5,
+      "sites": 3,
+      "width": 5,
+      "cutoff": 5,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 765,
+      "budget": 6400,
+      "width_volume": 8,
+      "depth": 1,
+      "visited_cells": 25,
+      "visited_bound": "121/4",
+      "cutoff_visited": 7,
+      "cutoff_input_cells": 7,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 3,
+      "width": 6,
+      "cutoff": 6,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 860,
+      "budget": 7200,
+      "width_volume": 9,
+      "depth": 1,
+      "visited_cells": 28,
+      "visited_bound": "69/2",
+      "cutoff_visited": 8,
+      "cutoff_input_cells": 8,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 3,
+      "width": 6,
+      "cutoff": 7,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 115,
+      "budget": 4800,
+      "width_volume": 6,
+      "depth": 0,
+      "visited_cells": 19,
+      "visited_bound": "67/2",
+      "cutoff_visited": 8,
+      "cutoff_input_cells": 9,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 5,
+      "sites": 3,
+      "width": 24,
+      "cutoff": 5,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 2631,
+      "budget": 28800,
+      "width_volume": 36,
+      "depth": 1,
+      "visited_cells": 66,
+      "visited_bound": "92",
+      "cutoff_visited": 7,
+      "cutoff_input_cells": 7,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 3,
+      "width": 25,
+      "cutoff": 5,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 13,
+      "events": 58,
+      "steps": 4974,
+      "budget": 39200,
+      "width_volume": 49,
+      "depth": 2,
+      "visited_cells": 75,
+      "visited_bound": "385/4",
+      "cutoff_visited": 7,
+      "cutoff_input_cells": 7,
+      "comparisons": 4,
+      "exact_remainder_scans": 8
+    },
+    {
+      "base": 5,
+      "sites": 3,
+      "width": 26,
+      "cutoff": 6,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 3086,
+      "budget": 32800,
+      "width_volume": 41,
+      "depth": 1,
+      "visited_cells": 72,
+      "visited_bound": "199/2",
+      "cutoff_visited": 8,
+      "cutoff_input_cells": 8,
+      "comparisons": 4,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 5,
+      "sites": 3,
+      "width": 24,
+      "cutoff": 100003,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 313,
+      "budget": 19200,
+      "width_volume": 24,
+      "depth": 0,
+      "visited_cells": 55,
+      "visited_bound": "110",
+      "cutoff_visited": 26,
+      "cutoff_input_cells": 100005,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 5,
+      "sites": 3,
+      "width": 20,
+      "cutoff": 6,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 2306,
+      "budget": 25600,
+      "width_volume": 32,
+      "depth": 1,
+      "visited_cells": 59,
+      "visited_bound": "80",
+      "cutoff_visited": 8,
+      "cutoff_input_cells": 8,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 1,
+      "width": 1,
+      "cutoff": 1,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 400,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "73/6",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 3,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 7,
+      "sites": 1,
+      "width": 6,
+      "cutoff": 7,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 48,
+      "budget": 2400,
+      "width_volume": 6,
+      "depth": 0,
+      "visited_cells": 12,
+      "visited_bound": "33",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 9,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 7,
+      "sites": 1,
+      "width": 7,
+      "cutoff": 7,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 479,
+      "budget": 3200,
+      "width_volume": 8,
+      "depth": 1,
+      "visited_cells": 31,
+      "visited_bound": "229/6",
+      "cutoff_visited": 9,
+      "cutoff_input_cells": 9,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 1,
+      "width": 8,
+      "cutoff": 8,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 526,
+      "budget": 3600,
+      "width_volume": 9,
+      "depth": 1,
+      "visited_cells": 34,
+      "visited_bound": "127/3",
+      "cutoff_visited": 10,
+      "cutoff_input_cells": 10,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 1,
+      "width": 8,
+      "cutoff": 9,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 149,
+      "budget": 3200,
+      "width_volume": 8,
+      "depth": 0,
+      "visited_cells": 23,
+      "visited_bound": "124/3",
+      "cutoff_visited": 10,
+      "cutoff_input_cells": 11,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 7,
+      "sites": 1,
+      "width": 48,
+      "cutoff": 7,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 2105,
+      "budget": 21600,
+      "width_volume": 54,
+      "depth": 1,
+      "visited_cells": 118,
+      "visited_bound": "168",
+      "cutoff_visited": 9,
+      "cutoff_input_cells": 9,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 1,
+      "width": 49,
+      "cutoff": 7,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 14,
+      "steps": 2596,
+      "budget": 22800,
+      "width_volume": 57,
+      "depth": 2,
+      "visited_cells": 129,
+      "visited_bound": "1033/6",
+      "cutoff_visited": 9,
+      "cutoff_input_cells": 9,
+      "comparisons": 2,
+      "exact_remainder_scans": 4
+    },
+    {
+      "base": 7,
+      "sites": 1,
+      "width": 50,
+      "cutoff": 8,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 2302,
+      "budget": 22800,
+      "width_volume": 57,
+      "depth": 1,
+      "visited_cells": 124,
+      "visited_bound": "526/3",
+      "cutoff_visited": 10,
+      "cutoff_input_cells": 10,
+      "comparisons": 2,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 1,
+      "width": 34,
+      "cutoff": 100003,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 435,
+      "budget": 13600,
+      "width_volume": 34,
+      "depth": 0,
+      "visited_cells": 75,
+      "visited_bound": "449/3",
+      "cutoff_visited": 36,
+      "cutoff_input_cells": 100005,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 7,
+      "sites": 1,
+      "width": 28,
+      "cutoff": 8,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 2,
+      "events": 8,
+      "steps": 1336,
+      "budget": 12800,
+      "width_volume": 32,
+      "depth": 1,
+      "visited_cells": 77,
+      "visited_bound": "317/3",
+      "cutoff_visited": 10,
+      "cutoff_input_cells": 10,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 2,
+      "width": 1,
+      "cutoff": 1,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 600,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "73/6",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 3,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 7,
+      "sites": 2,
+      "width": 6,
+      "cutoff": 7,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 48,
+      "budget": 3600,
+      "width_volume": 6,
+      "depth": 0,
+      "visited_cells": 12,
+      "visited_bound": "33",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 9,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 7,
+      "sites": 2,
+      "width": 7,
+      "cutoff": 7,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 723,
+      "budget": 5400,
+      "width_volume": 9,
+      "depth": 1,
+      "visited_cells": 31,
+      "visited_bound": "229/6",
+      "cutoff_visited": 9,
+      "cutoff_input_cells": 9,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 2,
+      "width": 8,
+      "cutoff": 8,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 794,
+      "budget": 6000,
+      "width_volume": 10,
+      "depth": 1,
+      "visited_cells": 34,
+      "visited_bound": "127/3",
+      "cutoff_visited": 10,
+      "cutoff_input_cells": 10,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 2,
+      "width": 8,
+      "cutoff": 9,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 149,
+      "budget": 4800,
+      "width_volume": 8,
+      "depth": 0,
+      "visited_cells": 23,
+      "visited_bound": "124/3",
+      "cutoff_visited": 10,
+      "cutoff_input_cells": 11,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 7,
+      "sites": 2,
+      "width": 48,
+      "cutoff": 7,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 3483,
+      "budget": 36000,
+      "width_volume": 60,
+      "depth": 1,
+      "visited_cells": 118,
+      "visited_bound": "168",
+      "cutoff_visited": 9,
+      "cutoff_input_cells": 9,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 2,
+      "width": 49,
+      "cutoff": 7,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 7,
+      "events": 32,
+      "steps": 4941,
+      "budget": 40200,
+      "width_volume": 67,
+      "depth": 2,
+      "visited_cells": 129,
+      "visited_bound": "1033/6",
+      "cutoff_visited": 9,
+      "cutoff_input_cells": 9,
+      "comparisons": 3,
+      "exact_remainder_scans": 6
+    },
+    {
+      "base": 7,
+      "sites": 2,
+      "width": 50,
+      "cutoff": 8,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 3842,
+      "budget": 38400,
+      "width_volume": 64,
+      "depth": 1,
+      "visited_cells": 124,
+      "visited_bound": "526/3",
+      "cutoff_visited": 10,
+      "cutoff_input_cells": 10,
+      "comparisons": 3,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 2,
+      "width": 34,
+      "cutoff": 100003,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 435,
+      "budget": 20400,
+      "width_volume": 34,
+      "depth": 0,
+      "visited_cells": 75,
+      "visited_bound": "449/3",
+      "cutoff_visited": 36,
+      "cutoff_input_cells": 100005,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 7,
+      "sites": 2,
+      "width": 28,
+      "cutoff": 8,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 3,
+      "events": 12,
+      "steps": 2174,
+      "budget": 21600,
+      "width_volume": 36,
+      "depth": 1,
+      "visited_cells": 77,
+      "visited_bound": "317/3",
+      "cutoff_visited": 10,
+      "cutoff_input_cells": 10,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 3,
+      "width": 1,
+      "cutoff": 1,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 18,
+      "budget": 800,
+      "width_volume": 1,
+      "depth": 0,
+      "visited_cells": 7,
+      "visited_bound": "73/6",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 3,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 7,
+      "sites": 3,
+      "width": 6,
+      "cutoff": 7,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 48,
+      "budget": 4800,
+      "width_volume": 6,
+      "depth": 0,
+      "visited_cells": 12,
+      "visited_bound": "33",
+      "cutoff_visited": 1,
+      "cutoff_input_cells": 9,
+      "comparisons": 0,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 7,
+      "sites": 3,
+      "width": 7,
+      "cutoff": 7,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 967,
+      "budget": 8000,
+      "width_volume": 10,
+      "depth": 1,
+      "visited_cells": 31,
+      "visited_bound": "229/6",
+      "cutoff_visited": 9,
+      "cutoff_input_cells": 9,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 3,
+      "width": 8,
+      "cutoff": 8,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 1062,
+      "budget": 8800,
+      "width_volume": 11,
+      "depth": 1,
+      "visited_cells": 34,
+      "visited_bound": "127/3",
+      "cutoff_visited": 10,
+      "cutoff_input_cells": 10,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 3,
+      "width": 8,
+      "cutoff": 9,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 149,
+      "budget": 6400,
+      "width_volume": 8,
+      "depth": 0,
+      "visited_cells": 23,
+      "visited_bound": "124/3",
+      "cutoff_visited": 10,
+      "cutoff_input_cells": 11,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 7,
+      "sites": 3,
+      "width": 48,
+      "cutoff": 7,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 4861,
+      "budget": 52800,
+      "width_volume": 66,
+      "depth": 1,
+      "visited_cells": 118,
+      "visited_bound": "168",
+      "cutoff_visited": 9,
+      "cutoff_input_cells": 9,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 3,
+      "width": 49,
+      "cutoff": 7,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 13,
+      "events": 58,
+      "steps": 7774,
+      "budget": 63200,
+      "width_volume": 79,
+      "depth": 2,
+      "visited_cells": 129,
+      "visited_bound": "1033/6",
+      "cutoff_visited": 9,
+      "cutoff_input_cells": 9,
+      "comparisons": 4,
+      "exact_remainder_scans": 8
+    },
+    {
+      "base": 7,
+      "sites": 3,
+      "width": 50,
+      "cutoff": 8,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 5382,
+      "budget": 56800,
+      "width_volume": 71,
+      "depth": 1,
+      "visited_cells": 124,
+      "visited_bound": "526/3",
+      "cutoff_visited": 10,
+      "cutoff_input_cells": 10,
+      "comparisons": 4,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 7,
+      "sites": 3,
+      "width": 34,
+      "cutoff": 100003,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 435,
+      "budget": 27200,
+      "width_volume": 34,
+      "depth": 0,
+      "visited_cells": 75,
+      "visited_bound": "449/3",
+      "cutoff_visited": 36,
+      "cutoff_input_cells": 100005,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 7,
+      "sites": 3,
+      "width": 28,
+      "cutoff": 8,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 4,
+      "events": 16,
+      "steps": 3012,
+      "budget": 32000,
+      "width_volume": 40,
+      "depth": 1,
+      "visited_cells": 77,
+      "visited_bound": "317/3",
+      "cutoff_visited": 10,
+      "cutoff_input_cells": 10,
+      "comparisons": 1,
+      "exact_remainder_scans": 2
+    },
+    {
+      "base": 2,
+      "sites": 3,
+      "width": 63,
+      "cutoff": 2,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 364,
+      "events": 1696,
+      "steps": 107106,
+      "budget": 772800,
+      "width_volume": 966,
+      "depth": 5,
+      "visited_cells": 228,
+      "visited_bound": "267",
+      "cutoff_visited": 4,
+      "cutoff_input_cells": 4,
+      "comparisons": 121,
+      "exact_remainder_scans": 242
+    },
+    {
+      "base": 3,
+      "sites": 2,
+      "width": 257,
+      "cutoff": 3,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 63,
+      "events": 312,
+      "steps": 55213,
+      "budget": 414600,
+      "width_volume": 691,
+      "depth": 5,
+      "visited_cells": 740,
+      "visited_bound": "1831/2",
+      "cutoff_visited": 5,
+      "cutoff_input_cells": 5,
+      "comparisons": 31,
+      "exact_remainder_scans": 62
+    },
+    {
+      "base": 7,
+      "sites": 1,
+      "width": 4097,
+      "cutoff": 100001,
+      "origins": [
+        0,
+        0,
+        0,
+        0
+      ],
+      "nodes": 1,
+      "events": 2,
+      "steps": 45128,
+      "budget": 1638800,
+      "width_volume": 4097,
+      "depth": 0,
+      "visited_cells": 8201,
+      "visited_bound": "102473/6",
+      "cutoff_visited": 4099,
+      "cutoff_input_cells": 100003,
+      "comparisons": 1,
+      "exact_remainder_scans": 0
+    },
+    {
+      "base": 5,
+      "sites": 3,
+      "width": 500,
+      "cutoff": 17,
+      "origins": [
+        -17,
+        4,
+        29,
+        -9
+      ],
+      "nodes": 40,
+      "events": 184,
+      "steps": 101967,
+      "budget": 870400,
+      "width_volume": 1088,
+      "depth": 3,
+      "visited_cells": 1248,
+      "visited_bound": "1653",
+      "cutoff_visited": 19,
+      "cutoff_input_cells": 19,
+      "comparisons": 13,
+      "exact_remainder_scans": 26
+    },
+    {
+      "base": 7,
+      "sites": 4,
+      "width": 301,
+      "cutoff": 7,
+      "origins": [
+        8,
+        -25,
+        -3,
+        42
+      ],
+      "nodes": 21,
+      "events": 92,
+      "steps": 59719,
+      "budget": 569000,
+      "width_volume": 569,
+      "depth": 2,
+      "visited_cells": 705,
+      "visited_bound": "5821/6",
+      "cutoff_visited": 9,
+      "cutoff_input_cells": 9,
+      "comparisons": 5,
+      "exact_remainder_scans": 10
+    }
+  ]
+}
diff --git a/research/selected-rank-control/evidence/root-replay.json b/research/selected-rank-control/evidence/root-replay.json
new file mode 100644
index 0000000000..9608e62246
--- /dev/null
+++ b/research/selected-rank-control/evidence/root-replay.json
@@ -0,0 +1,148 @@
+{
+  "normal_optimized_byte_equal": true,
+  "receipts": {
+    "general_normal": {
+      "finite_cases": 896,
+      "formal_kernel": "not_run",
+      "independent_dense_cases": 9,
+      "kappa": "unchanged",
+      "maximum_observed_steps_over_splus1_mass": "2509/96",
+      "negative_controls": 10,
+      "nodes": 13540,
+      "selected_payload_implementation": "not_claimed",
+      "shape_blowup": [
+        {
+          "depth": 0,
+          "nodes": 1,
+          "width": 1
+        },
+        {
+          "depth": 1,
+          "nodes": 4,
+          "width": 2
+        },
+        {
+          "depth": 2,
+          "nodes": 13,
+          "width": 4
+        },
+        {
+          "depth": 3,
+          "nodes": 40,
+          "width": 8
+        },
+        {
+          "depth": 4,
+          "nodes": 121,
+          "width": 16
+        },
+        {
+          "depth": 5,
+          "nodes": 364,
+          "width": 32
+        },
+        {
+          "depth": 6,
+          "nodes": 1093,
+          "width": 64
+        },
+        {
+          "depth": 7,
+          "nodes": 3280,
+          "width": 128
+        },
+        {
+          "depth": 8,
+          "nodes": 9841,
+          "width": 256
+        }
+      ],
+      "status": "PASS_ONLINE_RANK_CONTROL",
+      "transitions": 3469732
+    },
+    "general_optimized": {
+      "finite_cases": 896,
+      "formal_kernel": "not_run",
+      "independent_dense_cases": 9,
+      "kappa": "unchanged",
+      "maximum_observed_steps_over_splus1_mass": "2509/96",
+      "negative_controls": 10,
+      "nodes": 13540,
+      "selected_payload_implementation": "not_claimed",
+      "shape_blowup": [
+        {
+          "depth": 0,
+          "nodes": 1,
+          "width": 1
+        },
+        {
+          "depth": 1,
+          "nodes": 4,
+          "width": 2
+        },
+        {
+          "depth": 2,
+          "nodes": 13,
+          "width": 4
+        },
+        {
+          "depth": 3,
+          "nodes": 40,
+          "width": 8
+        },
+        {
+          "depth": 4,
+          "nodes": 121,
+          "width": 16
+        },
+        {
+          "depth": 5,
+          "nodes": 364,
+          "width": 32
+        },
+        {
+          "depth": 6,
+          "nodes": 1093,
+          "width": 64
+        },
+        {
+          "depth": 7,
+          "nodes": 3280,
+          "width": 128
+        },
+        {
+          "depth": 8,
+          "nodes": 9841,
+          "width": 256
+        }
+      ],
+      "status": "PASS_ONLINE_RANK_CONTROL",
+      "transitions": 3469732
+    },
+    "selected_normal": {
+      "cases": 2400,
+      "controls": 8,
+      "cutoff": "supplied input; production not claimed",
+      "independent_dense_cases": 8,
+      "kappa": "unchanged",
+      "m3_sites2_instructions": 288,
+      "nodes": 10878,
+      "remainder_zero": "explicit B0/A0 hooks; consumer must skip payload work",
+      "status": "PASS_SELECTED_UNIFORM_CONTROL",
+      "transitions": 3443893
+    },
+    "selected_optimized": {
+      "cases": 2400,
+      "controls": 8,
+      "cutoff": "supplied input; production not claimed",
+      "independent_dense_cases": 8,
+      "kappa": "unchanged",
+      "m3_sites2_instructions": 288,
+      "nodes": 10878,
+      "remainder_zero": "explicit B0/A0 hooks; consumer must skip payload work",
+      "status": "PASS_SELECTED_UNIFORM_CONTROL",
+      "transitions": 3443893
+    }
+  },
+  "status": "PASS_SELECTED_RANK_CONTROL_PACKAGE"
+}
diff --git a/research/selected-rank-control/evidence/selected_normal.json b/research/selected-rank-control/evidence/selected_normal.json
new file mode 100644
index 0000000000..c88d26c8cc
--- /dev/null
+++ b/research/selected-rank-control/evidence/selected_normal.json
@@ -0,0 +1,12 @@
+{
+  "cases": 2400,
+  "controls": 8,
+  "cutoff": "supplied input; production not claimed",
+  "independent_dense_cases": 8,
+  "kappa": "unchanged",
+  "m3_sites2_instructions": 288,
+  "nodes": 10878,
+  "remainder_zero": "explicit B0/A0 hooks; consumer must skip payload work",
+  "status": "PASS_SELECTED_UNIFORM_CONTROL",
+  "transitions": 3443893
+}
diff --git a/research/selected-rank-control/evidence/selected_optimized.json b/research/selected-rank-control/evidence/selected_optimized.json
new file mode 100644
index 0000000000..c88d26c8cc
--- /dev/null
+++ b/research/selected-rank-control/evidence/selected_optimized.json
@@ -0,0 +1,12 @@
+{
+  "cases": 2400,
+  "controls": 8,
+  "cutoff": "supplied input; production not claimed",
+  "independent_dense_cases": 8,
+  "kappa": "unchanged",
+  "m3_sites2_instructions": 288,
+  "nodes": 10878,
+  "remainder_zero": "explicit B0/A0 hooks; consumer must skip payload work",
+  "status": "PASS_SELECTED_UNIFORM_CONTROL",
+  "transitions": 3443893
+}
diff --git a/research/selected-rank-control/independent_check.py b/research/selected-rank-control/independent_check.py
new file mode 100644
index 0000000000..4980c13206
--- /dev/null
+++ b/research/selected-rank-control/independent_check.py
@@ -0,0 +1,313 @@
+"""Independent dense CPU and materialized address-tree oracle for selected control.
+
+No author Machine, Tape, input constructor or verifier is called. Compile-time
+Builder output is the program under test. Prepared for CubeJerry with substantial
+OpenAI assistance. Apache-2.0.
+"""
+from fractions import Fraction
+from hashlib import sha256
+from importlib.util import module_from_spec, spec_from_file_location
+from pathlib import Path
+from types import ModuleType
+import json
+import sys
+
+PKG = Path(sys.argv[1]).resolve() if len(sys.argv)>1 else Path(__file__).resolve().parent
+BLANK, ONE, MARK = '_', '1', '|'
+
+
+def need(test, message):
+    if not test:
+        raise AssertionError(message)
+
+
+def load(name, path):
+    spec = spec_from_file_location(name, path)
+    module = module_from_spec(spec)
+    sys.modules[name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+reference = load('controller_reference', PKG/'controller_reference.py')
+
+
+def forbidden(*args, **kwargs):
+    raise AssertionError('author runtime/helper invoked')
+
+
+reference.Machine = reference.Tape = reference.initial_tapes = forbidden
+subject = load('selected_control', PKG/'selected_control.py')
+
+
+def materialized_tree(width, cutoff, base, sites):
+    """Breadth-first materialization, then independently sorted contour events."""
+    nodes = [((), width, (), ())]
+    cursor = 0
+    while cursor < len(nodes):
+        path, size, sort_prefix, ancestors = nodes[cursor]
+        cursor += 1
+        if size >= max(base, cutoff):
+            for site in range(sites):
+                nodes.append((path+(site,), size//base, sort_prefix+(3+3*site,),
+                              ancestors+((size,site),)))
+    events = []
+    for path, size, prefix, ancestors in nodes:
+        if size < max(base,cutoff):
+            events.extend([(prefix+(0,), 'L',size,path,ancestors),
+                           (prefix+(1,), 'X',size,path,ancestors)])
+        else:
+            events.extend([(prefix+(0,), 'E',size,path,ancestors),
+                           (prefix+(1,), 'B'+str(size%base),size,path,ancestors)])
+            for site in range(sites):
+                events.extend([
+                    (prefix+(2+3*site,), 'D'+str(site),size//base,path+(site,),
+                     ancestors+((size,site),)),
+                    (prefix+(4+3*site,), 'U'+str(site),size,path,ancestors)])
+            events.extend([(prefix+(2+3*sites,), 'A'+str(size%base),size,path,ancestors),
+                           (prefix+(3+3*sites,), 'X',size,path,ancestors)])
+    events.sort(key=lambda event:event[0])
+    return nodes,events
+
+
+def dense_program(code, alphabet):
+    symbols = {symbol:i for i,symbol in enumerate(alphabet)}
+    result = []
+    for instruction in code:
+        op,*args = instruction
+        if op=='read':
+            tape,arms = args
+            result.append((0,tape,tuple(arms.get(symbol,-1) for symbol in alphabet)))
+        elif op=='write':
+            result.append((1,args[0],symbols[args[1]]))
+        elif op=='move':
+            need(args[1] in (-1,1),'literal unit move')
+            result.append((2,args[0],args[1]))
+        elif op=='goto': result.append((3,args[0]))
+        elif op=='emit': result.append((4,args[0]))
+        elif op=='halt': result.append((5,))
+        else: raise AssertionError('unknown instruction')
+    return tuple(result),symbols
+
+
+class DenseCPU:
+    """Independently decoded six-opcode CPU over four dense symbol arrays."""
+    def __init__(self, code, alphabet, width, cutoff, origins, stack_extent):
+        self.program,self.symbols = dense_program(code,alphabet)
+        self.alphabet,self.origins = alphabet,origins
+        self.heads = list(origins)
+        self.lows,self.highs = list(origins),list(origins)
+        self.pc,self.steps = 0,0
+        self.visited_writes = [0,0,0,0]
+        self.mem,self.left,self.protected = [],[],[]
+        active = (width,width,stack_extent,cutoff)
+        for tape,(origin,extent) in enumerate(zip(origins,active)):
+            left,right = origin-8,origin+extent+9
+            cells = [self.symbols[BLANK]]*(right-left+1)
+            protected = []
+            for delta,symbol in ((-7,'t0'),(-6,'0'),(-4,ONE),(-3,MARK),(-2,'0')):
+                pos = origin+delta
+                cells[pos-left] = self.symbols[symbol]
+                protected.append(pos)
+            cells[origin-1-left] = self.symbols[MARK]
+            protected.append(origin-1)
+            # Input words are constructed here, without author helper code.
+            length = width if tape==0 else cutoff if tape==3 else 0
+            for offset in range(length): cells[origin+offset-left] = self.symbols[ONE]
+            # Hostile cells sit beyond the active window and its terminal blank.
+            for delta,symbol in ((extent+2,'0'),(extent+3,MARK),(extent+5,'t0')):
+                pos = origin+delta
+                cells[pos-left] = self.symbols[symbol]
+                protected.append(pos)
+            self.mem.append(cells)
+            self.left.append(left)
+            self.protected.append(tuple(protected))
+        self.initial = tuple(tuple(cells) for cells in self.mem)
+
+    def get(self,tape,position):
+        return self.mem[tape][position-self.left[tape]]
+
+    def unary_width(self):
+        origin = self.origins[0]
+        size = 0
+        while self.get(0,origin+size)==self.symbols[ONE]: size+=1
+        need(self.get(0,origin+size)==self.symbols[BLANK], 'unary terminator')
+        return size
+
+    def transition(self):
+        need(0<=self.pc<len(self.program),'program-counter range')
+        instruction = self.program[self.pc]
+        self.pc += 1
+        self.steps += 1
+        opcode = instruction[0]
+        if opcode==0:
+            tape,arms = instruction[1:]
+            target = arms[self.get(tape,self.heads[tape])]
+            need(target>=0,'unhandled scanned symbol')
+            self.pc = target
+        elif opcode==1:
+            tape,value = instruction[1:]
+            need(tape!=3,'cutoff write')
+            need(self.heads[tape] not in self.protected[tape],'protected-cell write')
+            self.mem[tape][self.heads[tape]-self.left[tape]] = value
+            self.visited_writes[tape] += 1
+        elif opcode==2:
+            tape,direction = instruction[1:]
+            self.heads[tape] += direction
+            need(self.origins[tape]-1<=self.heads[tape], 'read below entry marker')
+            need(self.left[tape]<=self.heads[tape]<self.left[tape]+len(self.mem[tape]),
+                 'dense window exceeded')
+            self.lows[tape] = min(self.lows[tape],self.heads[tape])
+            self.highs[tape] = max(self.highs[tape],self.heads[tape])
+        elif opcode==3: self.pc=instruction[1]
+        elif opcode==4: return instruction[1]
+        elif opcode==5: return False
+        return None
+
+
+def run_case(base,sites,width,cutoff,origins,compiler=subject.compile_selected,
+             mutate=None):
+    nodes,expected = materialized_tree(width,cutoff,base,sites)
+    code,alphabet = compiler(base,sites)
+    if mutate: code=mutate(code)
+    if compiler is subject.compile_selected and mutate is None:
+        need(len(code)==30*base+42+sites*(69+3*base),'exact transition census')
+        need(len(alphabet)==sites+4,'fixed alphabet census')
+    stack_extent=max(sum(size+1 for size,_ in ancestor) for *_,ancestor in nodes)
+    cpu = DenseCPU(code,alphabet,width,cutoff,origins,stack_extent)
+    budget=200*(sites+1)*sum(node[1] for node in nodes)
+    compare_pc=next(i for i,op in enumerate(code) if op[0]=='read' and op[1]==3)
+    next_event,last_event,compare = 0,None,None
+    remainder_scans,comparisons = 0,0
+    while True:
+        need(cpu.steps<budget,'transition envelope exceeded before halt')
+        if cpu.pc==compare_pc and cpu.heads[0]==origins[0] and cpu.heads[3]==origins[3]:
+            need(compare is None,'overlapping comparison')
+            compare=(cpu.steps,cpu.unary_width())
+        event=cpu.transition()
+        if event is False: break
+        if event is None: continue
+        need(next_event<len(expected),'extra event')
+        _,label,size,path,ancestors=expected[next_event]
+        next_event+=1
+        need(event==label,'event oracle mismatch')
+        need(cpu.unary_width()==size,'actual emitted WIDTH mismatch')
+        need(cpu.heads[0]==origins[0] and cpu.heads[1]==origins[1] and
+             cpu.heads[3]==origins[3], 'descriptor head not restored at emit')
+        need(all(cpu.get(0,origins[0]+j)==cpu.symbols[BLANK] for j in range(size,width+1)),
+             'stale width history at emit')
+        need(all(cpu.get(1,origins[1]+j)==cpu.symbols[BLANK] for j in range(width+1)),
+             'child history not retired at emit')
+        stack=[]
+        for ancestor,site in ancestors: stack.extend([ONE]*ancestor+['t'+str(site)])
+        need(cpu.heads[2]==origins[2]+len(stack),'stack cursor mismatch')
+        need(all(cpu.get(2,origins[2]+j)==cpu.symbols[symbol]
+                 for j,symbol in enumerate(stack)), 'materialized ancestor stack mismatch')
+        need(all(cpu.get(2,origins[2]+j)==cpu.symbols[BLANK]
+                 for j in range(len(stack),stack_extent+1)), 'retired stack history mismatch')
+        need(tuple(cpu.mem[3])==cpu.initial[3],'cutoff changed')
+        for tape in range(4):
+            need(all(cpu.get(tape,pos)==cpu.initial[tape][pos-cpu.left[tape]]
+                     for pos in cpu.protected[tape]), 'hostile exterior changed')
+        if label in ('E','L') and compare is not None:
+            begun,compared_width=compare
+            need(cpu.steps-begun<=11*min(compared_width,cutoff)+10,
+                 'comparison transition envelope')
+            comparisons+=1
+            compare=None
+        if label.startswith('B') or label.startswith('A'):
+            prior='E' if label.startswith('B') else 'U'+str(sites-1)
+            need(last_event is not None and last_event[0]==prior,'remainder predecessor')
+            need(cpu.steps-last_event[1]==6*size+7,'exact remainder transition charge')
+            remainder_scans+=1
+        last_event=(label,cpu.steps)
+    need(next_event==len(expected),'missing event')
+    need(cpu.steps<=budget,'complete transition envelope')
+    need(tuple(cpu.heads)==origins,'final head restoration')
+    need(tuple(tuple(cells) for cells in cpu.mem)==cpu.initial,'full final cell restoration')
+    visited=sum(high-low+1 for low,high in zip(cpu.lows,cpu.highs))
+    depth=max(len(node[0]) for node in nodes)
+    bound=2*(width+2)+Fraction(width*base,base-1)+depth+2+min(width,cutoff)+2
+    linear=(4+Fraction(base,base-1))*width+8
+    need(visited<=bound<=linear,'historical visited-interval envelope')
+    need(cpu.highs[3]-cpu.lows[3]+1<=min(width,cutoff)+2,'large cutoff visited prefix')
+    need(all(low>=origin-1 for low,origin in zip(cpu.lows,origins)),
+         'ancestor-prefix locality')
+    return dict(base=base,sites=sites,width=width,cutoff=cutoff,origins=origins,
+                nodes=len(nodes),events=len(expected),steps=cpu.steps,budget=budget,
+                width_volume=sum(node[1] for node in nodes),depth=depth,
+                visited_cells=visited,visited_bound=str(bound),
+                cutoff_visited=cpu.highs[3]-cpu.lows[3]+1,
+                cutoff_input_cells=cutoff+2,comparisons=comparisons,
+                exact_remainder_scans=remainder_scans)
+
+
+def negative_controls():
+    out=[]
+
+    def rejects(label,operation,wanted):
+        try: operation()
+        except AssertionError as error:
+            need(str(error)==wanted,'unexpected rejection for '+label+': '+str(error))
+            out.append(label)
+        else: raise AssertionError('negative control survived: '+label)
+
+    def wrong_remainder(code):
+        return tuple(('emit','A0') if op==('emit','A1') else op for op in code)
+    rejects('post remainder label changed',
+            lambda:run_case(3,2,10,3,(-9,7,21,-4),mutate=wrong_remainder),
+            'event oracle mismatch')
+
+    text=(PKG/'selected_control.py').read_text()
+    old="if r==m-1:a.op('write',CHILD,ONE);a.op('move',CHILD,1)"
+    need(text.count(old)==1,'unique quotient mutation site')
+    new=old+";a.op('write',CHILD,ONE);a.op('move',CHILD,1)"
+    mutant=ModuleType('wrong_quotient')
+    exec(compile(text.replace(old,new),'wrong-quotient-control','exec'),mutant.__dict__)
+    rejects('doubled quotient output',
+            lambda:run_case(3,1,3,3,(4,-8,13,27),compiler=mutant.compile_selected),
+            'actual emitted WIDTH mismatch')
+
+    def wrong_stop(code):
+        result=list(code)
+        at=next(i for i,op in enumerate(code) if op[0]=='read' and op[1]==3)
+        width_probe=code[at][2][ONE]
+        wrong=code[width_probe][2][BLANK]
+        result[at]=('read',3,{**code[at][2],BLANK:wrong})
+        return tuple(result)
+    rejects('cutoff equality treated as leaf',
+            lambda:run_case(3,2,9,9,(-17,20,4,-30),mutate=wrong_stop),
+            'event oracle mismatch')
+    return out
+
+
+def main():
+    pins={name:sha256((PKG/name).read_bytes()).hexdigest()
+          for name in ('selected_control.py','controller_reference.py','SOURCE-BINDING.md')}
+    need(pins['selected_control.py']=='1c977e9f4864d338f874aa4943d9f3422d964c3ab0cc2f877d9bc4c2d9e20237',
+         'selected source pin')
+    need(pins['controller_reference.py']=='e664a748e6b6797d4b60f60a7a7dd68b59a5608acf56b9c5d8b466f363755f73',
+         'controller source pin')
+    cases=[]
+    origins=((-17,4,29,-9),(8,-25,-3,42),(0,0,0,0))
+    for base in (2,3,5,7):
+        for sites in (1,2,3):
+            for width,cutoff in ((1,1),(base-1,base),(base,base),
+                                 (base+1,base+1),(base+1,base+2),
+                                 (base*base-1,base),(base*base,base),
+                                 (base*base+1,base+1),(5*base-1,100003),
+                                 (4*base,base+1)):
+                cases.append(run_case(base,sites,width,cutoff,origins[len(cases)%3]))
+    for base,sites,width,cutoff in ((2,3,63,2),(3,2,257,3),(7,1,4097,100001),
+                                   (5,3,500,17),(7,4,301,7)):
+        cases.append(run_case(base,sites,width,cutoff,origins[len(cases)%3]))
+    result=dict(status='PASS',method='separate dense CPU and materialized address-tree contour',
+                cases=len(cases),nodes=sum(row['nodes'] for row in cases),
+                events=sum(row['events'] for row in cases),
+                transitions=sum(row['steps'] for row in cases),
+                exact_remainder_scans=sum(row['exact_remainder_scans'] for row in cases),
+                negative_controls=negative_controls(),pins=pins,rows=cases)
+    print(json.dumps(result,indent=2))
+
+
+if __name__=='__main__': main()
diff --git a/research/selected-rank-control/selected_control.py b/research/selected-rank-control/selected_control.py
new file mode 100644
index 0000000000..b3ffa7c4ac
--- /dev/null
+++ b/research/selected-rank-control/selected_control.py
@@ -0,0 +1,59 @@
+"""Final rank-one control with supplied cutoff and explicit remainder hooks.
+
+The credited frozen Builder/interpreter performs literal local tape steps.
+No payload or external cutoff producer is included. Apache-2.0.
+"""
+from controller_reference import Builder,Machine,Tape,initial_tapes,BLANK,ONE,MARK,WIDTH,CHILD,STACK
+CUTOFF=3
+
+def remainder(a,m,prefix,event,next_state):
+    a.mark(prefix);a.op('goto',prefix+'r0')
+    for r in range(m):
+        a.mark(prefix+f'r{r}');a.op('read',WIDTH,{ONE:prefix+f'b{r}',BLANK:prefix+f'e{r}'})
+        a.mark(prefix+f'b{r}');a.op('move',WIDTH,1);a.op('goto',prefix+f'r{(r+1)%m}')
+        a.mark(prefix+f'e{r}');a.rewind(WIDTH,(ONE,));a.op('emit',event+str(r));a.op('goto',next_state)
+
+def compile_selected(m,sites):
+    if type(m) is not int or m<2 or type(sites) is not int or sites<1:raise ValueError('invalid fixed template')
+    tags=tuple(f't{i}' for i in range(sites));a=Builder();a.mark('enter');a.op('read',WIDTH,{ONE:'probe0'})
+    for k in range(m):
+        a.mark(f'probe{k}');a.op('read',WIDTH,{ONE:f'advance{k}',BLANK:f'leaf{k}'})
+        a.mark(f'advance{k}');a.op('move',WIDTH,1);a.op('goto',f'probe{k+1}' if k+1<m else 'width_at_least_m')
+        a.mark(f'leaf{k}');a.rewind(WIDTH,(ONE,));a.op('emit','L');a.op('goto','complete')
+    a.mark('width_at_least_m');a.rewind(WIDTH,(ONE,))
+    a.mark('compare');a.op('read',CUTOFF,{BLANK:'cutoff_reached',ONE:'width_probe'})
+    a.mark('width_probe');a.op('read',WIDTH,{BLANK:'shorter_than_cutoff',ONE:'compare_bit'})
+    a.mark('compare_bit');a.op('move',CUTOFF,1);a.op('move',WIDTH,1);a.op('goto','compare')
+    for label,event,dest in [('cutoff_reached','E','before'),('shorter_than_cutoff','L','complete')]:
+        a.mark(label);a.rewind(WIDTH,(ONE,));a.rewind(CUTOFF,(ONE,));a.op('emit',event);a.op('goto',dest)
+    remainder(a,m,'before','B','child0')
+    for i in range(sites):
+        a.mark(f'child{i}');a.op('goto',f'build{i}_0')
+        for r in range(m):
+            a.mark(f'build{i}_{r}');a.op('read',WIDTH,{ONE:f'build{i}_{r}bit',BLANK:f'built{i}'})
+            a.mark(f'build{i}_{r}bit')
+            if r==m-1:a.op('write',CHILD,ONE);a.op('move',CHILD,1)
+            a.op('move',WIDTH,1);a.op('goto',f'build{i}_{(r+1)%m}')
+        a.mark(f'built{i}');a.rewind(WIDTH,(ONE,));a.rewind(CHILD,(ONE,))
+        a.mark(f'push{i}');a.op('read',WIDTH,{ONE:f'push{i}bit',BLANK:f'pushed{i}'})
+        a.mark(f'push{i}bit');a.op('write',STACK,ONE);a.op('write',WIDTH,BLANK);a.op('move',WIDTH,1);a.op('move',STACK,1);a.op('goto',f'push{i}')
+        a.mark(f'pushed{i}');a.op('write',STACK,tags[i]);a.op('move',STACK,1);a.rewind(WIDTH,(BLANK,))
+        a.mark(f'transfer{i}');a.op('read',CHILD,{ONE:f'transfer{i}bit',BLANK:f'transferred{i}'})
+        a.mark(f'transfer{i}bit');a.op('write',WIDTH,ONE);a.op('write',CHILD,BLANK);a.op('move',WIDTH,1);a.op('move',CHILD,1);a.op('goto',f'transfer{i}')
+        a.mark(f'transferred{i}');a.rewind(WIDTH,(ONE,));a.rewind(CHILD,(BLANK,));a.op('emit',f'D{i}');a.op('goto','enter')
+    remainder(a,m,'after','A','complete')
+    a.mark('complete');a.op('emit','X');a.op('move',STACK,-1);a.op('read',STACK,{MARK:'root_done',**{t:f'return{i}' for i,t in enumerate(tags)}})
+    a.mark('root_done');a.op('move',STACK,1);a.op('halt')
+    for i in range(sites):
+        a.mark(f'return{i}');a.op('write',STACK,BLANK);a.op('move',STACK,-1)
+        a.mark(f'erase{i}');a.op('read',WIDTH,{ONE:f'erase{i}bit',BLANK:f'erased{i}'})
+        a.mark(f'erase{i}bit');a.op('write',WIDTH,BLANK);a.op('move',WIDTH,1);a.op('goto',f'erase{i}')
+        a.mark(f'erased{i}');a.rewind(WIDTH,(BLANK,));a.mark(f'pop{i}')
+        a.op('read',STACK,{ONE:f'pop{i}bit',MARK:f'popped{i}',**{t:f'popped{i}' for t in tags}})
+        a.mark(f'pop{i}bit');a.op('write',WIDTH,ONE);a.op('write',STACK,BLANK);a.op('move',WIDTH,1);a.op('move',STACK,-1);a.op('goto',f'pop{i}')
+        a.mark(f'popped{i}');a.op('move',STACK,1);a.rewind(WIDTH,(ONE,));a.op('emit',f'U{i}');a.op('goto',f'child{i+1}' if i+1<sites else 'after')
+    return a.finish((BLANK,'0',ONE,MARK,*tags))
+
+def inputs(width,cutoff,origins=(0,0,0,0)):
+    if type(cutoff) is not int or cutoff<1:raise ValueError('positive supplied cutoff')
+    t=initial_tapes(width,origins[:3]);o=origins[3];t.append(Tape({o-1:MARK,**{o+i:ONE for i in range(cutoff)}},o));return t
diff --git a/research/selected-rank-control/verify_all.py b/research/selected-rank-control/verify_all.py
new file mode 100644
index 0000000000..f0fe71602e
--- /dev/null
+++ b/research/selected-rank-control/verify_all.py
@@ -0,0 +1,38 @@
+"""Replay both bounded suites normally and under -O; compare exact receipts."""
+import json
+from pathlib import Path
+import subprocess
+import sys
+
+HERE = Path(__file__).resolve().parent
+SUITES = (
+    ("general", "verify_general.py", "PASS_ONLINE_RANK_CONTROL"),
+    ("selected", "verify_selected.py", "PASS_SELECTED_UNIFORM_CONTROL"),
+)
+
+
+def main():
+    receipts = {}
+    for name, script, expected in SUITES:
+        outputs = []
+        for optimized in (False, True):
+            command = [sys.executable] + (["-O"] if optimized else [])
+            command += ["-B", str(HERE / script)]
+            result = subprocess.run(command, cwd=HERE, capture_output=True,
+                                    text=True, timeout=120, check=True)
+            if result.stderr:
+                raise ValueError("unexpected stderr from " + script)
+            receipt = json.loads(result.stdout)
+            if receipt.get("status") != expected:
+                raise ValueError("unexpected status from " + script)
+            outputs.append(result.stdout)
+            receipts[name + ("_optimized" if optimized else "_normal")] = receipt
+        if outputs[0] != outputs[1]:
+            raise ValueError("normal/-O output differs for " + script)
+    print(json.dumps({"status": "PASS_SELECTED_RANK_CONTROL_PACKAGE",
+                      "normal_optimized_byte_equal": True,
+                      "receipts": receipts}, sort_keys=True, indent=2))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/research/selected-rank-control/verify_general.py b/research/selected-rank-control/verify_general.py
new file mode 100644
index 0000000000..f9f7b36b69
--- /dev/null
+++ b/research/selected-rank-control/verify_general.py
@@ -0,0 +1,122 @@
+"""Finite corroboration of the written all-size theorem."""
+import itertools,json
+from fractions import Fraction
+from controller_reference import compile_controller,initial_tapes,Machine,BLANK,ONE,MARK
+
+def need(ok,why):
+    if not ok: raise ValueError(why)
+
+def oracle(m,ranks,f):
+    ev=['L'] if f<m else ['E']; mass=f; nodes=1; depth=0
+    if f>=m:
+        for i,r in enumerate(ranks):
+            e,t,n,d=oracle(m,ranks,r*f//m)
+            ev += [f'D{i}']+e+[f'U{i}']; mass+=t; nodes+=n; depth=max(depth,d+1)
+    return ev+['X'],mass,nodes,depth
+
+def width_oracle(m,ranks,f):
+    result=[('L' if f<m else 'E',f)]
+    if f>=m:
+        for i,r in enumerate(ranks):
+            child=r*f//m
+            result += [(f'D{i}',child)]+width_oracle(m,ranks,child)+[(f'U{i}',f)]
+    return result+[('X',f)]
+
+def observed_run(code,tapes,bound):
+    z=Machine(code,tapes); widths=[]
+    while not z.halted:
+        need(z.steps<bound,'transition bound')
+        instruction=code[z.pc]
+        if instruction[0]=='emit':
+            widths.append((instruction[1],sum(s==ONE for s in tapes[0].cells.values())))
+        z.step()
+    return z,widths
+
+def run_case(m,ranks,f,origins=(0,0,0)):
+    code,abc=compile_controller(m,ranks)
+    need(len(code)==10*m+13+len(ranks)*(67+3*m)+2*sum(ranks),'state formula')
+    need(len(abc)==len(ranks)+4,'alphabet formula')
+    tapes=initial_tapes(f,origins); saved=[(t.cells.copy(),t.head) for t in tapes]
+    ev,mass,nodes,depth=oracle(m,ranks,f); bound=100*(len(ranks)+1)*mass
+    z,seen_widths=observed_run(code,tapes,bound)
+    need(seen_widths==width_oracle(m,ranks,f),'event-width mismatch')
+    need(z.events==ev,'shape/event mismatch')
+    need(all(t.cells==c and t.head==h for t,(c,h) in zip(tapes,saved)),'endpoint')
+    need(all(t.low>=o-1 for t,o in zip(tapes,origins)),'ancestor visit')
+    span=sum(t.high-t.low+1 for t in tapes); rho=Fraction(max(ranks),m)
+    need(span<=2*(f+2)+Fraction(f,1-rho)+depth+2,'retained span')
+    return z.steps,nodes,mass,z.events
+
+def dense_run(code,tapes,limit):
+    lo=min(t.head for t in tapes)-100; hi=max(t.head for t in tapes)+20000
+    a=[[BLANK]*(hi-lo+1) for _ in tapes]; h=[t.head for t in tapes]
+    for j,t in enumerate(tapes):
+        for p,s in t.cells.items(): a[j][p-lo]=s
+    pc=steps=0; events=[]
+    while steps<limit:
+        ins=code[pc]; op=ins[0]; steps+=1
+        if op=='halt': return steps,events,h,a,lo
+        if op=='read': pc=ins[2][a[ins[1]][h[ins[1]]-lo]]; continue
+        if op=='goto': pc=ins[1]; continue
+        if op=='move': h[ins[1]]+=ins[2]
+        elif op=='write': a[ins[1]][h[ins[1]]-lo]=ins[2]
+        elif op=='emit': events.append(ins[1])
+        else: raise ValueError('dense opcode')
+        pc+=1
+    raise ValueError('dense budget')
+
+def main():
+    count=steps=nodes=0; ratio=Fraction(0)
+    for m in range(2,5):
+        for s in range(1,4):
+            for ranks in itertools.product(range(1,m),repeat=s):
+                for f in range(1,17):
+                    st,no,mass,_=run_case(m,ranks,f)
+                    count+=1; steps+=st; nodes+=no; ratio=max(ratio,Fraction(st,(s+1)*mass))
+    independent=0
+    for m,ranks,f in [(2,(1,1,1),32),(5,(1,3,4),17),(7,(2,3,6),21)]:
+        for org in [(0,0,0),(-19,29,7),(73,-11,41)]:
+            code,_=compile_controller(m,ranks); original=initial_tapes(f,org)
+            st,no,mass,ev=run_case(m,ranks,f,org)
+            ds,de,dh,da,lo=dense_run(code,initial_tapes(f,org),st+1)
+            need((ds,de,dh)==(st,ev,list(org)),'dense CPU mismatch')
+            for j,t in enumerate(original):
+                need({i+lo:v for i,v in enumerate(da[j]) if v!=BLANK}==t.cells,'dense restoration')
+            independent+=1
+    controls=[]
+    for m,ranks in [(1,(1,)),(3,(0,)),(3,(3,)),(3,()),(3,(True,))]:
+        try: compile_controller(m,ranks)
+        except ValueError: controls.append('invalid-profile')
+        else: raise ValueError('invalid profile admitted')
+    code,_=compile_controller(3,(1,2)); expected,mass,_,_=oracle(3,(1,2),9)
+    bad=list(code); j=next(i for i,x in enumerate(bad) if x==('write',2,'t0')); bad[j]=('write',2,'t1')
+    need(Machine(tuple(bad),initial_tapes(9)).run().events!=expected,'wrong return missed'); controls.append('wrong-return')
+    bad=list(code); j=next(i for i,x in enumerate(bad) if x==('write',1,BLANK)); bad[j]=('write',1,ONE)
+    try:
+        z=Machine(tuple(bad),initial_tapes(9)).run(1000)
+    except ValueError: detected=True
+    else: detected=z.events!=expected or z.tapes[1].cells!={-1:MARK}
+    need(detected,'scratch leak missed'); controls.append('scratch-leak')
+    bad=list(code); j=next(i for i,x in enumerate(bad) if x==('write',1,ONE)); bad[j]=('write',1,BLANK)
+    try: z=Machine(tuple(bad),initial_tapes(9)).run(1000)
+    except ValueError: detected=True
+    else: detected=z.events!=expected
+    need(detected,'floor-transducer fault missed'); controls.append('floor-transducer')
+    narrow,_=compile_controller(3,(2,)); bad=list(narrow)
+    j=next(i for i,x in enumerate(bad) if x==('write',1,ONE)); bad[j]=('goto',j+2)
+    z,seen=observed_run(tuple(bad),initial_tapes(3),1000)
+    good,_,_,_=oracle(3,(2,),3)
+    need(z.events==good and seen!=width_oracle(3,(2,),3),'shape-only width fault missed')
+    controls.append('shape-identical-wrong-width')
+    try: Machine(code,initial_tapes(9)).run(1)
+    except ValueError: controls.append('undercharged-time')
+    else: raise ValueError('undercharged run admitted')
+    blowup=[]
+    for d in range(9):
+        f=2**d; expected_nodes=(3**(d+1)-1)//2
+        _,_,n,_=oracle(2,(1,1,1),f); need(n==expected_nodes,'node formula')
+        blowup.append({'depth':d,'width':f,'nodes':n})
+    print(json.dumps({'status':'PASS_ONLINE_RANK_CONTROL','finite_cases':count,'transitions':steps,'nodes':nodes,
+      'independent_dense_cases':independent,'negative_controls':len(controls),'maximum_observed_steps_over_splus1_mass':str(ratio),
+      'shape_blowup':blowup,'kappa':'unchanged','formal_kernel':'not_run','selected_payload_implementation':'not_claimed'},sort_keys=True,indent=2))
+if __name__=='__main__': main()
diff --git a/research/selected-rank-control/verify_selected.py b/research/selected-rank-control/verify_selected.py
new file mode 100644
index 0000000000..b2e145c2c7
--- /dev/null
+++ b/research/selected-rank-control/verify_selected.py
@@ -0,0 +1,90 @@
+"""Exact finite tests for rank-one cutoff/remainder control."""
+import json
+from fractions import Fraction
+from selected_control import compile_selected,inputs,Machine,ONE,BLANK,CUTOFF
+
+def need(ok,msg):
+    if not ok:raise ValueError(msg)
+
+def oracle(m,s,e,L):
+    if e<max(m,L):return [('L',e),('X',e)],e,1,0
+    r=e%m;q=e//m;out=[('E',e),(f'B{r}',e)];mass=e;nodes=1;depth=0
+    for i in range(s):
+        ev,z,n,d=oracle(m,s,q,L);out += [(f'D{i}',q)]+ev+[(f'U{i}',e)];mass+=z;nodes+=n;depth=max(depth,d+1)
+    return out+[(f'A{r}',e),('X',e)],mass,nodes,depth
+
+def observed(code,tapes,bound):
+    z=Machine(code,tapes);ev=[]
+    while not z.halted:
+        need(z.steps<bound,'transition budget')
+        ins=code[z.pc]
+        if ins[0]=='emit':ev.append((ins[1],sum(x==ONE for x in tapes[0].cells.values())))
+        z.step()
+    return z,ev
+
+def one(m,s,e,L,org=(0,0,0,0)):
+    code,abc=compile_selected(m,s);need(len(code)==30*m+42+s*(69+3*m),'instruction formula')
+    ts=inputs(e,L,org);snap=[(x.cells.copy(),x.head) for x in ts]
+    ev,mass,nodes,d=oracle(m,s,e,L);z,seen=observed(code,ts,200*(s+1)*mass)
+    need(seen==ev,'width/remainder/shape')
+    need(all(x.cells==c and x.head==h for x,(c,h) in zip(ts,snap)),'restoration')
+    need(all(x.low>=o-1 for x,o in zip(ts,org)),'ancestor locality')
+    span=sum(x.high-x.low+1 for x in ts)
+    need(span<=2*(e+2)+Fraction(e,1-Fraction(1,m))+d+2+min(e,L)+2,'backing')
+    need(ts[3].high-org[3]<=min(e,L),'cutoff prefix')
+    return z.steps,nodes,mass,ev
+
+def dense(code,ts,limit):
+    lo=min(x.head for x in ts)-30;hi=max(x.head for x in ts)+10000
+    arr=[[BLANK]*(hi-lo+1) for _ in ts];heads=[x.head for x in ts]
+    for j,t in enumerate(ts):
+        for p,c in t.cells.items():arr[j][p-lo]=c
+    pc=steps=0;ev=[]
+    while steps<limit:
+        ins=code[pc];op=ins[0];steps+=1
+        if op=='halt':return steps,ev,heads,arr,lo
+        if op=='goto':pc=ins[1];continue
+        if op=='read':pc=ins[2][arr[ins[1]][heads[ins[1]]-lo]];continue
+        if op=='move':heads[ins[1]]+=ins[2]
+        elif op=='write':arr[ins[1]][heads[ins[1]]-lo]=ins[2]
+        elif op=='emit':ev.append((ins[1],arr[0].count(ONE)))
+        else:raise ValueError('dense opcode')
+        pc+=1
+    raise ValueError('dense budget')
+
+def main():
+    count=steps=nodes=0
+    for m in range(2,6):
+        for s in range(1,4):
+            for e in range(1,21):
+                for L in range(1,11):
+                    t,n,_,_=one(m,s,e,L);count+=1;steps+=t;nodes+=n
+    independent=0
+    for m,s,e,L in [(3,2,14,5),(3,3,27,9),(5,3,76,15),(2,5,64,3)]:
+        for org in [(0,0,0,0),(-7,19,31,-11)]:
+            code,_=compile_selected(m,s);t,n,mass,ev=one(m,s,e,L,org);orig=inputs(e,L,org)
+            dt,de,dh,da,lo=dense(code,inputs(e,L,org),t+1)
+            need((dt,de,dh)==(t,ev,list(org)),'independent CPU')
+            need(all({k+lo:v for k,v in enumerate(a) if v!=BLANK}==o.cells for a,o in zip(da,orig)),'dense cells')
+            independent+=1
+    controls=[]
+    for m,s in [(1,2),(3,0),(3,True)]:
+        try:compile_selected(m,s)
+        except ValueError:controls.append('invalid-template')
+        else:raise ValueError('invalid accepted')
+    code,_=compile_selected(3,2);bad=list(code)
+    j=next(i for i,x in enumerate(bad) if x[0]=='read' and x[1]==CUTOFF)
+    targets=dict(bad[j][2]);targets[BLANK]=bad[j+1][2][BLANK];bad[j]=('read',CUTOFF,targets)
+    _,ev=observed(tuple(bad),inputs(5,5),5000);need(ev!=oracle(3,2,5,5)[0],'equality cutoff fault');controls.append('equality-cutoff')
+    for mode in ['wrong','omitted']:
+        bad=list(code);j=next(i for i,x in enumerate(bad) if x==('emit','A1'))
+        bad[j]=('emit','A0') if mode=='wrong' else ('goto',j+1)
+        _,ev=observed(tuple(bad),inputs(4,1),5000);need(ev!=oracle(3,2,4,1)[0],'post remainder fault');controls.append(mode+'-post-remainder')
+    bad=list(code);j=next(i for i,x in enumerate(bad) if x==('move',CUTOFF,1));bad[j]=('move',CUTOFF,0)
+    try:z,ev=observed(tuple(bad),inputs(8,5),5000)
+    except (ValueError,KeyError):caught=True
+    else:caught=ev!=oracle(3,2,8,5)[0]
+    need(caught,'cutoff motion fault');controls.append('cutoff-head')
+    need(2*(5//3)==2 and (2*5)//3==3,'mixed rounding control');controls.append('raw-mixed-law-mismatch')
+    print(json.dumps({'status':'PASS_SELECTED_UNIFORM_CONTROL','cases':count,'transitions':steps,'nodes':nodes,'independent_dense_cases':independent,'controls':len(controls),'m3_sites2_instructions':len(code),'remainder_zero':'explicit B0/A0 hooks; consumer must skip payload work','kappa':'unchanged','cutoff':'supplied input; production not claimed'},sort_keys=True,indent=2))
+if __name__=='__main__':main()