From 317e4a099488794c372f8a4ad1e70deef3626bbf Mon Sep 17 00:00:00 2001
From: Ali Romman <226877337+aliromman@users.noreply.github.com>
Date: Mon, 2 Nov 2026 23:10:29 -0600
Subject: [PATCH] Prove a complete selected-caller zero fiber with 86N bits

---
 research/selected-caller-zero-fiber/NOTICE    |  48 ++
 research/selected-caller-zero-fiber/PROOF.md  | 196 +++++
 research/selected-caller-zero-fiber/README.md |  55 ++
 .../selected-caller-zero-fiber/RESULT.json    | 773 ++++++++++++++++++
 .../selected-caller-zero-fiber/SOURCES.json   |  24 +
 research/selected-caller-zero-fiber/TASK.json |  83 ++
 .../selected-caller-zero-fiber/VERIFY.json    |  36 +
 research/selected-caller-zero-fiber/fiber.py  | 183 +++++
 research/selected-caller-zero-fiber/verify.py | 168 ++++
 9 files changed, 1566 insertions(+)
 create mode 100644 research/selected-caller-zero-fiber/NOTICE
 create mode 100644 research/selected-caller-zero-fiber/PROOF.md
 create mode 100644 research/selected-caller-zero-fiber/README.md
 create mode 100644 research/selected-caller-zero-fiber/RESULT.json
 create mode 100644 research/selected-caller-zero-fiber/SOURCES.json
 create mode 100644 research/selected-caller-zero-fiber/TASK.json
 create mode 100644 research/selected-caller-zero-fiber/VERIFY.json
 create mode 100644 research/selected-caller-zero-fiber/fiber.py
 create mode 100644 research/selected-caller-zero-fiber/verify.py

diff --git a/research/selected-caller-zero-fiber/NOTICE b/research/selected-caller-zero-fiber/NOTICE
new file mode 100644
index 0000000000..1b0628adc0
--- /dev/null
+++ b/research/selected-caller-zero-fiber/NOTICE
@@ -0,0 +1,48 @@
+New work: Ali Romman with substantial OpenAI Codex assistance. No subagents.
+Apache-2.0.
+
+DreamingOfClouds supplies the selected PR6030 word and its retained P104
+lineage. The source word is unchanged and is the only runtime external input.
+https://github.com/CrocSwap/integer-mult-bounds/pull/6030
+
+Ali Romman's PR6546 supplies the same-grid stochastic numerical ABI, its
+complete caller and retained-state inverse. This package studies its public
+output projection. It does not claim that the predecessor discards its record.
+The zero-native property follows from that pinned sampler's pair, phase and
+permutation formulas; its full native suite is not replayed here.
+https://github.com/CrocSwap/integer-mult-bounds/pull/6546
+https://github.com/aliromman/integer-mult-bounds/blob/ff038070b8d122a43993f2b2524154323cc6b4d7/research/selected-absolute-stochastic-caller/sampler.py
+
+PR6532 supplies the Gaussian pair and retained-seed inverse. PR6509 supplies
+the prior conserved-center family. Their numerical and native predecessors,
+including Cinna Davis / 1337isnot1337, Nick Petalas, Tekalign, JoyboyBrian,
+Arham Tahir and the retained native/compiler authors, keep their credit.
+https://github.com/CrocSwap/integer-mult-bounds/pull/6532
+https://github.com/CrocSwap/integer-mult-bounds/pull/6509
+
+zxv's PR6066 supplies signed-half residue recovery, matched inverse seeds and
+the earlier randomness-reuse warning. Nick Petalas's PR6418 sharpens that
+reuse boundary; no fresh-seed law is inferred from retained seeds here.
+https://github.com/CrocSwap/integer-mult-bounds/pull/6066
+https://github.com/CrocSwap/integer-mult-bounds/pull/6418
+
+Ali Romman's PR5323 and Discussion5303 prove a distinct inverse-code zero-fiber
+count and sharp recovery state. They retain JoyboyBrian's PR5035 kernel and
+Dillon's PR4933 mode/wrapper credit. PR6540 gives a separate coarse native
+period-lattice capacity theorem. These prior local counts are not the new
+whole-selected-caller causal fiber proved here.
+https://github.com/CrocSwap/integer-mult-bounds/pull/5323
+https://github.com/CrocSwap/integer-mult-bounds/discussions/5303
+https://github.com/CrocSwap/integer-mult-bounds/pull/5035
+https://github.com/CrocSwap/integer-mult-bounds/pull/4933
+https://github.com/CrocSwap/integer-mult-bounds/pull/6540
+
+PR6499 and PR6506 supply a different exact scalar entrance-grid contract and
+its Boolean lowering. Their input alignment is not replaced by the arbitrary
+same-grid input class used here, and this lower bound is not transferred to it.
+https://github.com/CrocSwap/integer-mult-bounds/pull/6499
+https://github.com/CrocSwap/integer-mult-bounds/pull/6506
+
+Pigeonhole counting, first-access dataflow and retained residues are classical.
+No global literature priority, physical implementation or minimum for all
+caller inputs is claimed.
diff --git a/research/selected-caller-zero-fiber/PROOF.md b/research/selected-caller-zero-fiber/PROOF.md
new file mode 100644
index 0000000000..95c7100d03
--- /dev/null
+++ b/research/selected-caller-zero-fiber/PROOF.md
@@ -0,0 +1,196 @@
+# A complete-caller zero fiber with 86N independent bits
+
+The same-grid numerical ABI of [PR #6546](https://github.com/CrocSwap/integer-mult-bounds/pull/6546)
+needs at least 86N bits of retained capacity for exact input recovery from its
+public output and unchanged seed, where N=512^f. At width one this is 44,032
+bits, or 5,504 bytes. The bound comes from a displayed family of actual legal
+public inputs that all give the same complete output. A matching code is exact
+on this family. It is not a claim that 86N bits suffice on every caller input.
+
+This is a source-bound information result. It does not price physical clean
+storage, prove a global minimum, invalidate the predecessor's error bounds,
+discharge a selected assumption or improve the complete kappa calculation.
+The predecessor already retains its inverse record; this result explains why
+that record cannot all be recovered from only its public output and seed.
+
+## Input, seed and data-access contract
+
+Use the 22,803-event selected [PR #6030](https://github.com/CrocSwap/integer-mult-bounds/pull/6030) word pinned in SOURCES.json. There are
+770 arbitrary public fields and 29 owned labels. Each public field has N
+complex coordinates in `h*Z[i]`, for fixed h>0. Owned fields follow the source
+INIT and CLEAR instructions. The argument uses the integer coordinates in
+units h. There is no extra divisibility promise on the public inputs.
+
+Fix the complete retained seed S. At a scalar instruction with q=p/D, the
+forward component map is `floor((p*x+u)/D)`, with `0<=u<D`. ADD adds this rounded
+increment to its destination, and SCALE overwrites its destination. A seed
+can serve the whole field. Each MOVE accesses its declared data field; it
+does not secretly read other public fields. Scalar operand reads and writes
+are exactly those in the source word. All maps are deterministic when S is
+fixed. Records do not feed back into the forward data path.
+
+For the zero-output statement, native maps must send the zero field to zero
+for every seed. This holds for the [fixed predecessor sampler](https://github.com/aliromman/integer-mult-bounds/blob/ff038070b8d122a43993f2b2524154323cc6b4d7/research/selected-absolute-stochastic-caller/sampler.py):
+in its pair rule, x=y=0 gives s=d=c=0 for either sign. Gaussian-unit phases
+and coordinate permutations preserve zero. Every native layer and tensor
+composition therefore preserves zero. All scalar quantizers preserve zero
+because floor(u/D)=0. COPY, INIT and CLEAR preserve a zero data state.
+
+The counting lower bound only needs a common output. It remains valid for
+other deterministic local native maps even if they do not preserve zero.
+In that case the common output is F_S(0), which need not be zero. The stronger
+zero value is not inferred without the stated zero-preserving contract.
+
+## The complete first-access census
+
+A field's first data access is its first read OR write. For ADD and COPY,
+both destination and source count. MOVE and SCALE access their destination.
+A first-write census alone would miss prior observations and is insufficient.
+
+Two independent passes, an event scan and a separate search for each public
+field, agree on every first access. Exactly 43 public fields first appear in
+a signed half-SCALE. All have p=+1 or p=-1 and D=2. RESULT.json lists each
+field, event, sign and frame. The fields are
+
+```text
+205,210,204,200,211,215,188,194,186,196,202,179,207,177,176,168,
+167,214,216,218,222,157,161,160,172,141,140,219,135,134,152,150,
+126,143,123,120,181,180,137,118,159,130,734.
+```
+
+The first is field 205 at event index 2. The last is field 734 at index 10447.
+The first native MOVE is index 9896, so the proof must continue through native
+calls before the last independent input is lost. It is not only a scalar-prefix
+claim. Indices are zero based; the final independent label disappears at cut
+10448, after that many completed events.
+
+## A seedwise family of complete inputs
+
+Let j(r) be the first-access half for a cohort field r. Its sign is p_r and
+its retained seed is u_r in {0,1}. For each real and imaginary coordinate k,
+choose an independent bit b_(r,k), and set the initial input to
+
+```text
+x_(r,k) = p_r*(b_(r,k)-u_r).
+```
+
+Set every other public component to zero. Every component has absolute value
+at most one, so the physical inputs use only -h, 0 and h. There are exactly
+`43*2*N` independent bits, and different bit arrays give different complete
+public inputs. The all-zero input belongs to this family: choose b_(r,k)=u_r.
+
+Before event j(r), no instruction reads or writes field r. It therefore still
+contains its original coordinates. At that event,
+
+```text
+floor((p_r*x_(r,k)+u_r)/2) = floor(b_(r,k)/2) = 0,
+(p_r*x_(r,k)+u_r) mod 2 = b_(r,k).
+```
+
+Use induction over every source event. Unconsumed family bits occur only in
+their untouched input fields. All other live fields have values independent
+of those bits. An instruction before the relevant first access cannot read
+one of these fields. A certified half removes that field's bits from the data
+state. Every other instruction acts on bit-independent data. Thus after cut
+10448 the complete data state is independent of all bits, and the remainder
+of the word has the same complete public output for every member of the family.
+
+With zero-preserving native maps, strengthen the induction: every field apart
+from those untouched inputs is exactly zero. A half maps its secret input to
+zero. Every remaining instruction preserves zero. Consequently
+
+```text
+F_S(x) = 0 for all 2^(86*N) inputs in the displayed family,
+for every fixed legal complete seed S.
+```
+
+The native interface and the source read set are explicit hypotheses. Hidden
+reads of an untouched field could export its bits before the half and defeat
+this proof. The executable causal checker rejects such a prior read. It also
+checks the entire frame/ownership ledger and all 3,453 native zero operands.
+
+## Retained capacity, dirty storage and the exact family code
+
+An exact inverse from the public output, unchanged seed and b retained bits
+must distinguish all members of the zero fiber. It therefore requires
+
+```text
+2^b >= 2^(86*N), hence b >= 86*N.
+```
+
+This is additional information besides the declared public output and seed.
+Original input copies, changed seed contents, hidden tags or other output
+metadata count as retained information if they carry the distinction.
+
+A finite arbitrary dirty bank with Q possible initial states cannot reduce
+the bound while its information remains recoverable. The input slice has
+`2^(86*N)*Q` possibilities. The public output and unchanged seed are fixed,
+so a b-bit record and a Q-state output bank have at most `2^b*Q` states.
+Injectivity again gives b>=86N. This is a capacity count, not an initially
+clean register lower bound or a proof about infinite auxiliary storage.
+
+On the displayed family the bound is attained. Read the residue bit of each
+of the 43 first-access halves in event order, with real/imaginary coordinates
+in fixed order, and pack them. Given the unchanged 43 half seeds, reconstruct
+x by the formula above and set the other public inputs to zero. Exactly 86N
+bits suffice. Byte padding is zero; for N=512^f no padding is needed. The
+codec rejects inputs outside this family. It is not a general inverse for
+all inputs of the complete stochastic caller.
+
+These bits are present literally in the predecessor's division record. On
+this family every other division residue is determined by its seed, and all
+old COPY/CLEAR values are zero. Thus the 86N-bit variation is an actual joint
+record distinction; it is not obtained by adding unrelated local lower bounds.
+No claim is made that the other records are recoverable on general inputs.
+
+## A fixed input pair and fresh randomness
+
+The seedwise family is a worst-case exact-recovery argument. It does not
+require that an application choose its data after seeing the seed. There is
+also a fixed, seed-independent pair: the zero input and the input with real
+coordinate zero of field 205 equal to one, with every other component zero.
+The first two events do not read field 205. If the seed of event 2 is zero,
+its half maps either input to zero and every subsequent data field is zero.
+
+Under the predecessor's fresh uniform sampling law, this event has probability
+one half, regardless of later seeds. Thus this fixed pair has identical
+complete public outputs with probability AT LEAST one half. No exact claim
+is made about the final output for the other half seed. This is information
+loss on a positive-probability event, not a failure of the stated numerical
+error tolerance. Exact retained-state inversion still works as designed.
+
+## Scope boundaries and verification
+
+The lower bound is for unrestricted public h-grid inputs of this numerical
+ABI. If all public coordinates are promised to be even in these units, each
+pair `p*(b-u)` has only its zero member left. The displayed family then collapses
+to one input. The bound does not transfer automatically to the finer exact
+scalar entrance grids in [PR #6499](https://github.com/CrocSwap/integer-mult-bounds/pull/6499)
+or to correlated public inputs reached by an actual multiplication encoding.
+It also does not prohibit compute/copy/uncompute while the original input
+remains available, or changes to the forward word, output encoding or seed ABI.
+
+The verifier authenticates the word, performs both first-access censuses,
+and proves the full causal label invariant. It checks every signed-half coin
+and bit, 86 individual label positions, and the exact packed family code.
+Fifty-three complete scalar/zero-contract replays cover 1,208,559 source
+events, including two width-one 512-coordinate cases. Smaller one- and
+four-coordinate cases test the dimension-independent contract. At each MOVE,
+the verifier checks that its input is exactly zero and applies only the
+proved zero contract. It does NOT run a compiled native implementation.
+
+Nine semantic/domain controls cover prior reads, first-write confusion,
+restricted grids, a biased zero map, nonzero padding, a truncated label, outside-family
+inputs and a wrong retained seed. Source corruption is rejected. The large
+fiber is proved by independent parameters and induction, not enumerated.
+The pair sampler's zero behavior is read from its pinned implementation;
+its complete native/scientific suite is not replayed here. No independent
+human or proof-kernel acceptance, physical circuit/tape bill, full selected
+cold replay or global maximum-fiber calculation is claimed.
+
+The retained-bit and zero-fiber method is classical and has prior local
+source-bound instances in [PR #6066](https://github.com/CrocSwap/integer-mult-bounds/pull/6066),
+[PR #5323](https://github.com/CrocSwap/integer-mult-bounds/pull/5323) and
+[PR #6540](https://github.com/CrocSwap/integer-mult-bounds/pull/6540).
+The new contribution is the complete selected-caller causal fiber, its
+independent 43-field census, the 86N-bit joint bound and its exact scope.
diff --git a/research/selected-caller-zero-fiber/README.md b/research/selected-caller-zero-fiber/README.md
new file mode 100644
index 0000000000..0e4f261f0b
--- /dev/null
+++ b/research/selected-caller-zero-fiber/README.md
@@ -0,0 +1,55 @@
+# A complete-caller zero fiber with 86N independent bits
+
+The selected same-grid stochastic caller has a displayed family of
+`2^(86*N)` distinct public inputs with identical complete output for each
+fixed retained seed. All input coordinates are in {-h,0,h}. Native maps that
+preserve zero make that common output exactly zero, as in [PR #6546](https://github.com/CrocSwap/integer-mult-bounds/pull/6546)'s sampler.
+Exact recovery with an unchanged seed therefore needs at least `86*N` bits
+of retained capacity. At `N=512`, this is 44,032 bits, or 5,504 bytes.
+
+The proof identifies all 43 public fields whose first read or write is a
+signed half-SCALE. It follows their independent bits through every source
+event, including native calls before the last half at event 10447. An exact
+packed code attains the bound on the displayed family. It is not a claim
+about the maximum fiber or minimum record for all caller inputs.
+
+A fixed input pair independent of the seed also has identical complete output
+with probability at least one half under fresh sampling. This does not
+invalidate the predecessor's numerical error theorem: its retained-state
+inverse preserves the information that the public output loses.
+
+[PROOF.md](PROOF.md) gives the argument, scope and counting model.
+[RESULT.json](RESULT.json) gives the cohort and exact receipt.
+[fiber.py](fiber.py) contains the two censuses, causal checker and family code.
+[verify.py](verify.py) runs the independent finite corroboration and controls.
+[SOURCES.json](SOURCES.json) and [NOTICE](NOTICE) retain source pins and credit.
+
+Use CPython 3.12 and the standard library:
+
+```sh
+python3.12 -B scripts/research_package.py --package research/selected-caller-zero-fiber
+```
+
+The normal and optimized commands check all 22,803 source events, all public
+first accesses, 53 complete scalar/zero-contract replays (1,208,559 events),
+the family codec, 86 individual bit witnesses, nine semantic/domain controls
+and a source-corruption rejection. Each native operand must be exactly zero;
+this package uses its proved zero contract and does not run compiled natives.
+The exponential fiber size follows from the proof, not exhaustive enumeration.
+
+The lower bound is for arbitrary same-grid public inputs and exact recovery
+from the public output, unchanged seed and any declared extra state. It is
+not a clean hardware-storage minimum. Original input copies count as retained
+information. A promise of even input coordinates removes this displayed
+family. Physical routing, sampling, cleanup, true caller input correlations
+and all five complete framework assumptions remain open. No new kappa or
+selected-frontier change is claimed.
+
+## Open next questions
+
+Determine the complete map's maximum fiber or a smaller full-input recovery
+code. Before applying this lower bound to a physical caller, verify that its
+entrance encoding admits the displayed independent inputs and that native
+operations have no undeclared reads. Price all retained copies, tags and
+cleanup under that actual contract. The 86N-bit family alone does not settle
+those questions.
diff --git a/research/selected-caller-zero-fiber/RESULT.json b/research/selected-caller-zero-fiber/RESULT.json
new file mode 100644
index 0000000000..35d38dcf7d
--- /dev/null
+++ b/research/selected-caller-zero-fiber/RESULT.json
@@ -0,0 +1,773 @@
+{
+  "schema_version": 1,
+  "status": "PASS_SELECTED_CALLER_ZERO_FIBER",
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "source_sha256": "7834725d9e34ee846a9ccc615221ea81e0201613938afa185d2eda0c9a6c232f",
+  "cohort": [
+    {
+      "event": 2,
+      "field": 205,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 167,
+      "field": 210,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 321,
+      "field": 204,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 431,
+      "field": 200,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 571,
+      "field": 211,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 642,
+      "field": 215,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 785,
+      "field": 188,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 909,
+      "field": 194,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 1064,
+      "field": 186,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 1219,
+      "field": 196,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 1381,
+      "field": 202,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 1461,
+      "field": 179,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 1518,
+      "field": 207,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 1661,
+      "field": 177,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 1802,
+      "field": 176,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 1947,
+      "field": 168,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 2101,
+      "field": 167,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 2244,
+      "field": 214,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 2396,
+      "field": 216,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 2473,
+      "field": 218,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 2487,
+      "field": 222,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 2761,
+      "field": 157,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 2914,
+      "field": 161,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 3067,
+      "field": 160,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 3228,
+      "field": 172,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 3375,
+      "field": 141,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 3551,
+      "field": 140,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 3703,
+      "field": 219,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 3860,
+      "field": 135,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 3998,
+      "field": 134,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 4145,
+      "field": 152,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 4284,
+      "field": 150,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 4435,
+      "field": 126,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 4611,
+      "field": 143,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 4754,
+      "field": 123,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 4970,
+      "field": 120,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 5119,
+      "field": 181,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 5297,
+      "field": 180,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 5461,
+      "field": 137,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 5725,
+      "field": 118,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 5920,
+      "field": 159,
+      "sign": -1,
+      "frame": 3
+    },
+    {
+      "event": 8007,
+      "field": 130,
+      "sign": 1,
+      "frame": 3
+    },
+    {
+      "event": 10447,
+      "field": 734,
+      "sign": 1,
+      "frame": 306
+    }
+  ],
+  "cohort_fields": 43,
+  "independent_labels_per_complex_coordinate": 86,
+  "width_one_complex_coordinates": 512,
+  "width_one_retained_bits": 44032,
+  "width_one_packed_bytes": 5504,
+  "first_native_event": 9896,
+  "cohort_after_first_native": [
+    {
+      "event": 10447,
+      "field": 734,
+      "sign": 1,
+      "frame": 306
+    }
+  ],
+  "causal_proof": {
+    "events": 22803,
+    "native_zero_calls": 3453,
+    "peak_live_fields": 783,
+    "all_event_causal_sha256": "fd8c5d718f000c6aa40f5127bf9a5fae8665e226b5c98b0e058fcc1335a51477",
+    "last_secret_cut": 10448
+  },
+  "finite_checks": {
+    "full_source_replays": 53,
+    "literal_event_executions": 1208559,
+    "cases": [
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 0,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 0,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 0,
+        "label_fixture": 2,
+        "label_sha256": "18bb03d9b37672716f54c3abc3ca8df84a4f25dec5f5fafba6884ef613791b57",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 1,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 1,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 1,
+        "label_fixture": 2,
+        "label_sha256": "a0b0bb5832284158116e1564005ba22651ba9c4e377fc239d2cb7e9ccb0c531b",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 2,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 2,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 2,
+        "label_fixture": 2,
+        "label_sha256": "56f383f085064a2cc195101b741e019cb753105d10472377f03b57060c11ca0d",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 3,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 3,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 3,
+        "label_fixture": 2,
+        "label_sha256": "f181adeffabc9c98acf3a6aa383886e7d5ee49e269c816d4d330f8aac5ac2019",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 4,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 4,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 4,
+        "label_fixture": 2,
+        "label_sha256": "b82b0df56d3abe8bb3f2412c3cde8441f2e5db91e8dc618cd5090c37d9cc5b3f",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 5,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 5,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 5,
+        "label_fixture": 2,
+        "label_sha256": "dce78439388d950a1c20b990ff0e1dd2c08841c91c6054e5914834403320690b",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 6,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 6,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 6,
+        "label_fixture": 2,
+        "label_sha256": "227a3b4f4566e0ef4e4c34b43595962a0c92c910f99fc677b231d14f50095b54",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 7,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 7,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 7,
+        "label_fixture": 2,
+        "label_sha256": "a3782acdf7df2c783c540a835938ef7adefaa3d789fb57e457dd2587699c5e1d",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 8,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 8,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 8,
+        "label_fixture": 2,
+        "label_sha256": "f88e0e875a5b063afe8c3cea87f19a6aa6aa565b0d397df5619e40318b0d2249",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 9,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 9,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 9,
+        "label_fixture": 2,
+        "label_sha256": "13f2c02c5d1e5cb5210bc79a92f38321ad8050d4413c7eec16c3f83e953b40bb",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 10,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 10,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 10,
+        "label_fixture": 2,
+        "label_sha256": "cba0a990fe7079277e5d6082ae3d31556a34eae8d0db57c06ace243f9f624558",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 11,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 11,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 11,
+        "label_fixture": 2,
+        "label_sha256": "bdbef5703b13361de2da04ddaece95c076b271aee6516b11a89bb9f96bcd6c7e",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 12,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 12,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 12,
+        "label_fixture": 2,
+        "label_sha256": "f26e55b4863f8ada4fb064657e8006d5420c92846475d2a7d0d4cf1da2565c11",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 13,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 13,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 13,
+        "label_fixture": 2,
+        "label_sha256": "5cdf341fe94db97bdb5c393749ba21a12fe06d88a38d8423cc72d4debf07e122",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 14,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 14,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 14,
+        "label_fixture": 2,
+        "label_sha256": "7b652d6ba2b8f28883863190e375a5e53a13c411dc6ba4b86e32e9fffbe3ac59",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 15,
+        "label_fixture": 0,
+        "label_sha256": "71b6c1d53832f789a7f2435a7c629245fa3761ad8487775ebf4957330213a706",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 15,
+        "label_fixture": 1,
+        "label_sha256": "b3ca5a99c2d71bb903c891fb8a4149a365eb10e9efa315ddc2048d235f284717",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 1,
+        "seed_fixture": 15,
+        "label_fixture": 2,
+        "label_sha256": "f3986f56e0bb1bdc611fce9a649b7271000944bab5975f0e6bb0b5fd973939fe",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 4,
+        "seed_fixture": 0,
+        "label_fixture": 2,
+        "label_sha256": "511b0068773c2b562571876c8789cb334875131650c47e728e6d915c6ec5f0f0",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 4,
+        "seed_fixture": 1,
+        "label_fixture": 2,
+        "label_sha256": "345883cf86d3a7fba6c460cd55d458160b0438e539dc839462188d49c5e6e808",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 512,
+        "seed_fixture": 0,
+        "label_fixture": 2,
+        "label_sha256": "59a109e2d9019cfedf661b55f04d663eda5b6054648c4ab2ccbdb591ef205a0e",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      },
+      {
+        "complex_coordinates": 512,
+        "seed_fixture": 1,
+        "label_fixture": 2,
+        "label_sha256": "a505e8c8e0b8ea64509012710e4152a73ced9b312a369c086638a1b9e42f7a52",
+        "events": 22803,
+        "native_zero_calls": 3453,
+        "maximum_touched_component": 0
+      }
+    ],
+    "all_half_fiber_endpoints": 8,
+    "individual_retained_bit_witnesses": 86,
+    "fixed_input_pair_cylinder_probability": "1/2",
+    "fixed_pair_replay": {
+      "events": 22803,
+      "native_zero_calls": 3453,
+      "maximum_touched_component": 0
+    },
+    "semantic_and_domain_controls": 9
+  },
+  "source_corruption_controls": 1,
+  "global_minimum_claimed": false,
+  "selected_frontier_changed": false
+}
diff --git a/research/selected-caller-zero-fiber/SOURCES.json b/research/selected-caller-zero-fiber/SOURCES.json
new file mode 100644
index 0000000000..120a707639
--- /dev/null
+++ b/research/selected-caller-zero-fiber/SOURCES.json
@@ -0,0 +1,24 @@
+{
+  "schema_version": 1,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "research/p104-helper470-twin-rung-removal/WORD.json.gz",
+      "usage": "input",
+      "git_blob": "22f9ab02d1b73ea0aa4b07ce445a14cc2602c760",
+      "sha256": "7834725d9e34ee846a9ccc615221ea81e0201613938afa185d2eda0c9a6c232f"
+    }
+  ]
+}
diff --git a/research/selected-caller-zero-fiber/TASK.json b/research/selected-caller-zero-fiber/TASK.json
new file mode 100644
index 0000000000..fb8e1bbd21
--- /dev/null
+++ b/research/selected-caller-zero-fiber/TASK.json
@@ -0,0 +1,83 @@
+{
+  "schema_version": 1,
+  "task_id": "uniform-transfer-audit",
+  "priority_revision": 8,
+  "base_commit": "7c49fe32c55de02c2c873655c804b16e4c3fef0a",
+  "original_card": {
+    "id": "uniform-transfer-audit",
+    "question": "Can one of the selected record's five inherited assumptions be proved at its actual caller?",
+    "starting_points": [
+      "docs/research/current-priorities.md",
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md"
+    ],
+    "methods": [
+      "Construct and independently check one source-bound instance of the stated first experiment.",
+      "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change."
+    ],
+    "acceptance_gate": "Identify the proposition and what would change downstream; do not equate a finite replay with a universal proof.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_selected_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.",
+      "scope": "Source-bound orientation only, not a supplier replay or theorem proof."
+    },
+    "first_experiment": "Choose one assumption ID (native_all_columns, owned_erasure, compiler, precision_tape, analytic_recovery), one quantified implication and exact dependency closure. Check current handoffs, including #5625 row reentry and #5707 root-prefix lowering, without treating their partial scope as the whole theorem. Prove or falsify that implication with a caller-bound argument; stop at the chosen obligation. Finite tests or root digits do not discharge an all-size statement.",
+    "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.",
+    "allowed_variations": [
+      "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes."
+    ],
+    "scope_change_triggers": [
+      "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.",
+      "Treating an archived proposal or local numerical pass as complete supplier admission."
+    ],
+    "overlap_terms": [
+      "native_all_columns",
+      "owned_erasure",
+      "compiler",
+      "precision_tape",
+      "analytic_recovery"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #4100: proposed unconditional construction and finite checks, without independent acceptance.",
+        "evidence": "research/unconditional-batched-crt/README.md",
+        "remaining": "Independent proof audit of one caller-bound all-size implication; all other premises remain explicit.",
+        "status": "author-checked",
+        "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.",
+        "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md",
+        "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.",
+        "status": "reviewed",
+        "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137",
+        "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+      }
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Prove a complete selected same-grid numerical caller zero fiber with 86N independent bits, a retained-capacity lower bound and a matching code on that family.",
+  "scope_change_reason": "The released PR6546 recovery question needs an actual whole-caller fiber. A local lossy operation alone does not prove a global retained-state requirement.",
+  "bottleneck_link": "The owned_erasure and precision_tape interfaces must account for information absent from the rounded public output. This proves one source-bound capacity obligation, not physical admission.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop after the complete causal proof, independent first-access census, bounded corroboration and explicit entrance/seed/native-read limits. Do not claim a global maximum fiber or physical minimum.",
+  "outcome": "completed",
+  "evidence": "PROOF.md and RESULT.json; normal and optimized commands are registered in VERIFY.json.",
+  "author": "Ali Romman",
+  "ai_assistance": "Substantial OpenAI Codex assistance. No subagents.",
+  "open_questions": [
+    {
+      "question": "What is the complete map maximum fiber, and which inputs does the physical caller actually admit?",
+      "why_it_matters": "The displayed family gives a lower bound but not a globally minimal record; stronger entrance alignment can exclude it.",
+      "first_step": "Bind the actual entrance encoding and all native read sets before seeking a full-input recovery code and paid cleanup.",
+      "blocked_by": "No actual physical entrance contract or global maximum-fiber proof is supplied here."
+    }
+  ]
+}
diff --git a/research/selected-caller-zero-fiber/VERIFY.json b/research/selected-caller-zero-fiber/VERIFY.json
new file mode 100644
index 0000000000..ee56647231
--- /dev/null
+++ b/research/selected-caller-zero-fiber/VERIFY.json
@@ -0,0 +1,36 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/p104-helper470-twin-rung-removal/WORD.json.gz"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-W",
+        "error",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 300,
+      "checks": "Independent complete first-access censuses; causal invariant through all selected events; scalar/zero-contract replays, exact family codec, scoped lower bound and semantic/source controls. Compiled native implementations are not run."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-W",
+        "error",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 300,
+      "checks": "Independent complete first-access censuses; causal invariant through all selected events; scalar/zero-contract replays, exact family codec, scoped lower bound and semantic/source controls. Compiled native implementations are not run."
+    }
+  ]
+}
diff --git a/research/selected-caller-zero-fiber/fiber.py b/research/selected-caller-zero-fiber/fiber.py
new file mode 100644
index 0000000000..82de18f71e
--- /dev/null
+++ b/research/selected-caller-zero-fiber/fiber.py
@@ -0,0 +1,183 @@
+"""Certify the complete caller's first-access zero fiber and its exact code."""
+
+from fractions import Fraction as Q
+from hashlib import sha256
+
+
+def need(ok, label):
+    if not ok:
+        raise ValueError(label)
+
+
+def census_forward(word):
+    seen, first = set(), {}
+    for j,e in enumerate(word['program']):
+        op,r=e[:2]
+        need(op in {'INIT','CLEAR','MOVE','ADD','COPY','SCALE'},'known source opcode')
+        operands=[r]
+        if op=='ADD' or op=='COPY':
+            operands.append(e[2])
+        for field in operands:
+            if field not in seen:
+                if field<word['public']:
+                    first[field]=(j,op)
+                seen.add(field)
+    cohort=[]
+    for field,(j,op) in sorted(first.items(),key=lambda item:item[1][0]):
+        if op=='SCALE':
+            q=Q(word['program'][j][2])
+            if q.denominator>1:
+                need(q.denominator==2 and abs(q.numerator)==1,'selected first-access division class')
+                cohort.append({'event':j,'field':field,'sign':q.numerator,'frame':word['program'][j][3]})
+    return first,cohort
+
+
+def census_by_field(word):
+    first,cohort={},[]
+    for role in range(word['public']):
+        for j,e in enumerate(word['program']):
+            used=e[1]==role
+            if e[0] in ('COPY','ADD') and e[2]==role:
+                used=True
+            if used:
+                first[role]=(j,e[0])
+                if e[0]=='SCALE':
+                    q=Q(e[2])
+                    if q.denominator>1:
+                        need(q.denominator==2 and abs(q.numerator)==1,'independent division class')
+                        cohort.append({'event':j,'field':role,'sign':q.numerator,'frame':e[3]})
+                break
+    return first,sorted(cohort,key=lambda row:row['event'])
+
+
+def certify(word,cohort):
+    """Track unread independent labels; only their declared halves remove them."""
+    secret={x['field']:x for x in cohort}
+    state={r:(r if r in secret else None) for r in range(word['public'])}
+    frames=dict(enumerate(word['initial']))
+    owned=set();consumed=set();coverage=sha256();moves=0;peak_live=len(state)
+    for j,e in enumerate(word['program']):
+        op,r=e[:2]
+        if op=='INIT':
+            need(r>=word['public'] and r not in state,'owned allocation')
+            state[r]=None;frames[r]=e[2];owned.add(r)
+        else:
+            need(r in state,'live destination')
+            if op=='SCALE' and state[r] is not None:
+                row=secret[r]
+                need(row['event']==j and Q(e[2])==Q(row['sign'],2),'secret first half')
+                need(frames[r]==e[3],'half frame')
+                consumed.add(r);state[r]=None
+            else:
+                need(state[r] is None,'unread input used before its half')
+                if op=='MOVE':
+                    need(frames[r]==e[2] and bool(e[4])==(r in owned),'native frame and ownership')
+                    frames[r]=e[3];moves+=1
+                elif op=='CLEAR':
+                    need(r in owned and frames[r]==e[2],'owned clear')
+                    del state[r];del frames[r];owned.remove(r)
+                elif op in ('ADD','COPY'):
+                    source=e[2]
+                    need(source in state and state[source] is None,'no prior source read')
+                    need(r!=source and frames[r]==frames[source]==e[-1],'scalar frames')
+                    q=Q(e[-2]);need(q and q.denominator & (q.denominator-1)==0,'dyadic scalar')
+                    if op=='COPY':
+                        need(q==1 and r in owned,'selected exact COPY')
+                elif op=='SCALE':
+                    q=Q(e[2]);need(q and q.denominator & (q.denominator-1)==0 and frames[r]==e[3],'ordinary scale')
+                else:
+                    raise ValueError('unknown instruction')
+        remaining={r for r,v in state.items() if v is not None}
+        need(remaining==set(secret)-consumed,'every unconsumed label stays private to its input field')
+        peak_live=max(peak_live,len(state))
+        coverage.update(f'{j}:{op}:{r}:{len(remaining)}:{len(state)};'.encode())
+    need(consumed==set(secret) and not owned,'all independent labels removed')
+    need(frames==dict(enumerate(word['final'])) and all(v is None for v in state.values()),'complete label-independent endpoint')
+    return {'events':len(word['program']),'native_zero_calls':moves,'peak_live_fields':peak_live,
+            'all_event_causal_sha256':coverage.hexdigest(),'last_secret_cut':1+max(x['event'] for x in cohort)}
+
+
+def scalar_tape(word,mode):
+    tape=[]
+    for j,e in enumerate(word['program']):
+        if e[0] in ('ADD','COPY','SCALE'):
+            d=Q(e[-2]).denominator
+            if mode==0:
+                u=0
+            elif mode==1:
+                u=d-1
+            else:
+                u=int.from_bytes(sha256(f'zero-fiber:{mode}:{j}'.encode()).digest()[:8],'little')%d
+            tape.append(u)
+        else:
+            tape.append(None)
+    return tape
+
+
+def check_half_seeds(cohort,seeds):
+    need(len(seeds)==len(cohort) and all(type(u) is int and u in (0,1) for u in seeds),
+         'one retained half seed per cohort field')
+
+
+def decode_family(word,cohort,n,seeds,packed):
+    check_half_seeds(cohort,seeds)
+    bits=2*n*len(cohort)
+    need(type(n) is int and n>=1 and len(packed)==(bits+7)//8,'packed family length')
+    need(not bits%8 or packed[-1] >> (bits%8)==0,'packed zero padding')
+    inputs=[[0]*(2*n) for _ in range(word['public'])]
+    pos=0
+    for item,u in zip(cohort,seeds):
+        for k in range(2*n):
+            bit=(packed[pos//8] >> (pos%8)) & 1
+            inputs[item['field']][k]=item['sign']*(bit-u)
+            pos+=1
+    return inputs
+
+
+def encode_family(word,cohort,n,seeds,inputs):
+    check_half_seeds(cohort,seeds)
+    need(len(inputs)==word['public'] and all(len(v)==2*n for v in inputs),'family input shape')
+    roles={x['field'] for x in cohort}
+    need(all(all(x==0 for x in row) for r,row in enumerate(inputs) if r not in roles),'outside-family inputs')
+    bits=2*n*len(cohort);out=bytearray((bits+7)//8);pos=0
+    for item,u in zip(cohort,seeds):
+        for value in inputs[item['field']]:
+            need(type(value) is int,'integer grid')
+            bit=item['sign']*value+u
+            need(bit in (0,1),'family bit domain')
+            out[pos//8]|=bit << (pos%8);pos+=1
+    return bytes(out)
+
+
+def replay_zero_operands(word,initial,tape):
+    """Run every scalar literally; accept a native contract only at zero input."""
+    width=len(initial[0]);state={r:list(v) for r,v in enumerate(initial)}
+    native_calls=0;record=[];maximum=0
+    for j,e in enumerate(word['program']):
+        op,r=e[:2]
+        if op=='INIT':
+            state[r]=[0]*width
+        elif op=='CLEAR':
+            need(all(v==0 for v in state.pop(r)),'zero retained CLEAR value')
+        elif op=='COPY':
+            need(all(v==0 for v in state[r]),'zero old COPY value')
+            state[r]=state[e[2]].copy()
+        elif op=='MOVE':
+            need(all(v==0 for v in state[r]),'native zero-operand contract')
+            native_calls+=1
+        else:
+            need(op in ('ADD','SCALE'),'numerical opcode')
+            q=Q(e[-2]);u=tape[j]
+            need(type(u) is int and 0<=u<q.denominator,'scalar seed domain')
+            source=state[r] if op=='SCALE' else state[e[2]]
+            divided=[divmod(q.numerator*v+u,q.denominator) for v in source]
+            if op=='SCALE':
+                if q.denominator>1:
+                    record.append((j,[rem for value,rem in divided]))
+                state[r]=[value for value,rem in divided]
+            else:
+                state[r]=[v+z[0] for v,z in zip(state[r],divided)]
+        if r in state:
+            maximum=max(maximum,max(map(abs,state[r]),default=0))
+    need(set(state)==set(range(word['public'])) and all(v==0 for row in state.values() for v in row),'all public outputs zero')
+    return record,{'events':len(word['program']),'native_zero_calls':native_calls,'maximum_touched_component':maximum}
diff --git a/research/selected-caller-zero-fiber/verify.py b/research/selected-caller-zero-fiber/verify.py
new file mode 100644
index 0000000000..d842c13bcb
--- /dev/null
+++ b/research/selected-caller-zero-fiber/verify.py
@@ -0,0 +1,168 @@
+"""Verify the complete-source zero fiber, scoped optimum and its limits."""
+
+import copy
+import gzip
+import hashlib
+import json
+import sys
+from fractions import Fraction as Q
+from pathlib import Path
+
+HERE=Path(__file__).resolve().parent
+ROOT=HERE.parents[1]
+sys.path.insert(0,str(HERE))
+from fiber import (census_forward,census_by_field,certify,decode_family,encode_family,
+                   need,replay_zero_operands,scalar_tape)
+
+
+def check_source(data,expected):
+    need(hashlib.sha256(data).hexdigest()==expected,'source byte mismatch')
+
+
+def bits_for(count,mode):
+    data=bytearray((count+7)//8)
+    for j in range(count):
+        if mode==0:
+            bit=0
+        elif mode==1:
+            bit=1
+        else:
+            bit=hashlib.sha256(f'family-label:{mode}:{j}'.encode()).digest()[0]&1
+        data[j//8]|=bit << (j%8)
+    return bytes(data)
+
+
+def finite(word,cohort):
+    cases=[];local_codes=0
+    for n,modes in [(1,range(16)),(4,(0,1)),(512,(0,1))]:
+        patterns=(0,1,2) if n==1 else (2,)
+        for mode in modes:
+            tape=scalar_tape(word,mode);coins=[tape[r['event']] for r in cohort]
+            for pattern in patterns:
+                code=bits_for(2*n*len(cohort),pattern+mode*3 if pattern==2 else pattern)
+                inputs=decode_family(word,cohort,n,coins,code)
+                need(encode_family(word,cohort,n,coins,inputs)==code,'packed family bijection')
+                need(max(abs(v) for row in inputs for v in row)<=1,'bounded entrance coordinates')
+                record,stats=replay_zero_operands(word,inputs,tape)
+                record=dict(record)
+                decoded=[]
+                for item in cohort:
+                    decoded.extend(record[item['event']])
+                need(all(v in (0,1) for v in decoded),'literal residues are the family label')
+                need(all(v==((code[j//8] >> (j%8)) & 1) for j,v in enumerate(decoded)),
+                     'all independent bits occur in the existing division record')
+                for event,values in record.items():
+                    if event not in {r['event'] for r in cohort}:
+                        need(all(v==tape[event] for v in values),'other residues depend only on the fixed seed')
+                cases.append({'complex_coordinates':n,'seed_fixture':mode,'label_fixture':pattern,
+                              'label_sha256':hashlib.sha256(code).hexdigest(),**stats})
+    # One local enumeration checks every coin and bit, including both scale signs.
+    for sign in (-1,1):
+        for u in (0,1):
+            recovered=[]
+            for bit in (0,1):
+                x=sign*(bit-u);y,rem=divmod(sign*x+u,2)
+                need(y==0 and rem==bit and sign*(2*y+rem-u)==x,'all half fiber endpoints')
+                recovered.append(x);local_codes+=1
+            need(len(set(recovered))==2,'distinct bounded inputs')
+    # Every individual label position changes a legal input without changing the endpoint.
+    coins=[j%2 for j in range(len(cohort))];base=bytes((2*len(cohort)+7)//8)
+    baseline=decode_family(word,cohort,1,coins,base)
+    for j in range(2*len(cohort)):
+        bit=bytearray(base);bit[j//8]|=1 << (j%8)
+        other=decode_family(word,cohort,1,coins,bytes(bit))
+        need(other!=baseline and encode_family(word,cohort,1,coins,other)==bytes(bit),'retained-bit witness')
+    # A fixed input pair, independent of the seed, collides on a probability-1/2 cylinder.
+    tape=scalar_tape(word,0)
+    single=[[0]*2 for _ in range(word['public'])];single[205][0]=1
+    need(word['program'][2]==['SCALE',205,'1/2',3] and tape[2]==0,'fixed first-half cylinder')
+    _,single_stats=replay_zero_operands(word,single,tape)
+    controls=0
+    altered=copy.deepcopy(word)
+    altered['program'].insert(1,['ADD',778,205,'1',3])
+    try:
+        certify(altered,cohort)
+    except ValueError:
+        controls+=1
+    else:
+        raise ValueError('prior read was accepted')
+    _,changed=census_forward(altered)
+    need(len(changed)==len(cohort)-1 and 205 not in {r['field'] for r in changed},'first access differs from first write')
+    controls+=1
+    for u in (0,1):
+        legal=[bit for bit in (0,1) if (bit-u)%2==0]
+        need(legal==[u],'even entrance grid removes the displayed fiber')
+    controls+=1
+    # A prior read distinguishes the two inputs in this complete tiny caller.
+    need([(x//2,x) for x in (0,1)]==[(0,0),(0,1)],'prior-read countermodel')
+    controls+=1
+    # A biased zero map moves the common endpoint; it does not restore lost information.
+    need([(x//2,1) for x in (0,1)]==[(0,1),(0,1)],'zero-output versus common-fiber distinction')
+    controls+=1
+    code=bytearray(base);code[-1]|=128
+    try:
+        decode_family(word,cohort,1,coins,bytes(code))
+    except ValueError:
+        controls+=1
+    else:
+        raise ValueError('nonzero padding accepted')
+    try:
+        decode_family(word,cohort,1,coins,base[:-1])
+    except ValueError:
+        controls+=1
+    else:
+        raise ValueError('truncated label accepted')
+    bad=copy.deepcopy(baseline);bad[0][0]=1
+    try:
+        encode_family(word,cohort,1,coins,bad)
+    except ValueError:
+        controls+=1
+    else:
+        raise ValueError('input outside the named family accepted')
+    wrong=coins.copy();wrong[0]^=1
+    need(decode_family(word,cohort,1,wrong,base)!=baseline,'wrong retained seed changes the original input')
+    controls+=1
+    return {'full_source_replays':len(cases)+1,'literal_event_executions':(len(cases)+1)*len(word['program']),
+            'cases':cases,'all_half_fiber_endpoints':local_codes,'individual_retained_bit_witnesses':2*len(cohort),
+            'fixed_input_pair_cylinder_probability':'1/2','fixed_pair_replay':single_stats,
+            'semantic_and_domain_controls':controls}
+
+
+def run(generate):
+    row=next(x for x in json.loads((HERE/'SOURCES.json').read_text())['files'] if x['usage']=='input')
+    data=(ROOT/row['path']).read_bytes();check_source(data,row['sha256'])
+    try:
+        check_source(data+b'!',row['sha256'])
+    except ValueError:
+        corrupted=1
+    else:
+        raise ValueError('source corruption accepted')
+    word=json.loads(gzip.decompress(data))
+    first,cohort=census_forward(word);other,second=census_by_field(word)
+    need(first==other and cohort==second and len(first)==770,'independent complete first-access census')
+    need(len(cohort)==43,'source cohort count')
+    causal=certify(word,cohort);checks=finite(word,cohort)
+    result={'schema_version':1,'status':'PASS_SELECTED_CALLER_ZERO_FIBER',
+            'base_commit':'7c49fe32c55de02c2c873655c804b16e4c3fef0a','source_sha256':row['sha256'],
+            'cohort':cohort,'cohort_fields':len(cohort),'independent_labels_per_complex_coordinate':2*len(cohort),
+            'width_one_complex_coordinates':512,'width_one_retained_bits':512*2*len(cohort),
+            'width_one_packed_bytes':512*2*len(cohort)//8,
+            'first_native_event':next(j for j,e in enumerate(word['program']) if e[0]=='MOVE'),
+            'cohort_after_first_native':[x for x in cohort if x['event']>=9896],
+            'causal_proof':causal,'finite_checks':checks,'source_corruption_controls':corrupted,
+            'global_minimum_claimed':False,'selected_frontier_changed':False}
+    if generate:
+        (HERE/'RESULT.json').write_text(json.dumps(result,indent=2)+'\n')
+    else:
+        need(result==json.loads((HERE/'RESULT.json').read_text()),'committed exact receipt')
+    print('PASS_SELECTED_CALLER_ZERO_FIBER')
+    print(json.dumps({'cohort_fields':len(cohort),'retained_bits_per_coordinate':2*len(cohort),
+                      'width_one_bits':result['width_one_retained_bits'],'causal':causal,
+                      'full_source_replays':checks['full_source_replays'],
+                      'literal_event_executions':checks['literal_event_executions'],
+                      'controls':checks['semantic_and_domain_controls'],'source_corruption_controls':corrupted},sort_keys=True))
+
+
+if __name__=='__main__':
+    need(sys.argv[1:] in ([],['--generate']),'verifier arguments')
+    run(bool(sys.argv[1:]))