RESOURCE-LIMITED SELF-MODELS — CONSOLIDATED REPORT, ITERATION 3 OF 3

Preserved consolidated research report from 4 November 2026. This is broader supporting material for the selected public addendum, not another final manuscript or new external review. Original internal-review and result claims remain dated research records. Local path references are omitted in this public derivative; no original is edited. Original SHA-256: 62a8ac3e44f0a8f42e53845fc2db1e15b3027ee327c5f4ef6874f8fc4be105ff.
RESOURCE-LIMITED SELF-MODELS — CONSOLIDATED REPORT, ITERATION 3 OF 3
Learning, cross-context audits, and the limits of a declared model family
Prepared for Brian, 4 November 2026 (Asia/Bangkok)
Status: proved finite-model statements and exact synthetic checks; research draft.

RESULT

Two scalar audit ports are necessary and sufficient to cover the two declared
interactions in this experiment. They leave four final contexts entirely unseen.
With 18 noisy baseline observations and 6 noisy audit observations, the optimal
final normalized Hamming risk is 0.104. Identifying either interaction is harder:
its error is 0.186368 because the baseline itself was learned from noisy data.
The corresponding known-baseline error would be 0.104. Those are different
information contracts, not competing architectures at equal resources.

The modular controller and its efficient compiled comparator are exactly equal
on all paths. Both generated ROMs contain 181,505 logical bits, padded to 22,689
bytes. The joint prediction-and-diagnosis interface needs exactly 384 peak data
states at the chosen sample counts; prediction alone needs 96. An interaction
outside the declared family can remain invisible to every training and audit
observation. Accordingly, this is a finite audit of a stated family, not a
certificate that arbitrary unseen interactions are absent.

The three iterations support a reproducible benchmark and a precise resource
contract. They do not establish subjective awareness, an intrinsic advantage of
named modules, unrestricted out-of-distribution generalization, or a new general
theory. This is the final requested iteration; no fourth experiment is started.

1. CLAIM LEDGER ACROSS ALL THREE ITERATIONS

I1-A. Compilation null: a controller with named modules can be compiled while
retaining the same sufficient statistic and observation access. The compiled
implementation need not store histories or expand a product table. Proven by
state encoding and induction; compact counters instantiated in all three turns.
This does not prove equal minimal code, hardware, or engineering effort in every
possible architecture.

I1-B. For a fixed fair bit observed N=2k+1 times through fresh BSC(eta) noise,
0<eta<1/2, exact Bayes majority requires and suffices with k+2 data states. A
homogeneous capped count attains the bound. Below this capacity, clocked
deterministic risk exceeds Bayes risk by at least
  (1/2)(1-2 eta)[eta(1-eta)]^k.
This positive gap is not claimed sharp at every deficient capacity. Exact
posterior reports and full-information scalar Brier risk require N+1 terminal
states. Distinct posterior values and the squared-loss decomposition prove it.

I1-C. At N=3, eta=1/5, the exact classification frontier for clocked controllers
with S=1,2,3,4 states is .5, .152, .104, .104. Deterministic homogeneous S=2 gives
.2. Scalar Brier risks in the clocked class are 1/4, 22/175, 18064/203125,
688/8125; homogeneous S=2 gives 4/25. Exhaustive bounded checks corroborate the
proofs. Clocked versus homogeneous is not an equal-total-resource comparison.
Three and four states both fit in two physical bits. Exact rational reporting
can require Theta(N) serialized bits even when the count needs O(log N) bits.

I2-A. Six unknown local Boolean response entries are learned, rather than
supplied. With n odd repeats per entry, local-majority error is e_n, final
three-output vector failure is 1-(1-e_n)^3, and any of six learned entries wrong
has probability 1-(1-e_n)^6. These are exact Bayes and minimax risks in the
declared invariant family. At n=3: 18 scalar samples; risks .104, .280676864,
and .482574226015 respectively. Thirteen repeats per entry (78 samples) is the
minimum balanced odd allocation achieving at least .95 full-model success.
This is not an optimum over all adaptive allocations.

I2-B. Under the fixed blocked clocked schedule, peak data-state capacity is
2^5(k+2) for n=2k+1; terminal capacity is 64. Thus n=3 needs 96 peak states,
7 data bits, and a separate generic 5-bit clock. Both serialized implementations
were identical, 3,334 bytes. All 64 mechanisms and exact count outcomes were
checked, with a separate ROM decoder. Module identities, local dependencies,
trustworthy ports, and cross-context invariance were supplied assumptions.

I2-C. Without a restriction relating training to held-out responses, the 18
held-out response bits are unconstrained; uniform-prior and randomized minimax
Hamming risk is 1/2. This compares world classes, not weaker and stronger
controllers. A single invisible coupling bit flipping every mixed-context
output makes the factor-only learner's risk .896 when that bit is one. This
was a failure witness, not evidence that all possible interactions were tested.

I3-A. New: a frozen two-interaction family, separate training/audit/final split,
rowspace identifiability criterion, exact learned-baseline risk formulas, and
joint sample/data/clock/code ledger. Detailed proofs follow.

I3-B. New: independently checked 384-state joint-interface boundary, 96-state
prediction-only boundary, equal compiled ROMs, and a final-only interaction
whose unavoidable loss contribution is 1/24. These are specializations of
standard inference, linear algebra, and residual-function arguments. Priority
or broad mathematical novelty is not claimed.

2. FROZEN FAMILY, ACCESS, AND SPLIT

Let x=(x1,x2,x3) be one of eight Boolean configurations. There are six fixed
unknown local bits theta_{j,b}, j=1,2,3 and b=0,1. Component j has a response
F_j(x). For a desired Boolean command u, an action u XOR estimated F compensates
the response; prediction error and command mismatch coincide.

The iteration-3 family introduces two unknown interaction bits gamma_A,gamma_B:
  A={001,010,011}; B={100,101,110}.
  F1(x)=theta_{1,x1} XOR gamma_A, x in A;
         theta_{1,x1} XOR gamma_B, x in B;
         theta_{1,x1},             x in {000,111}.
  F2(x)=theta_{2,x2}; F3(x)=theta_{3,x3}.
All eight mechanism bits are fixed during the episode. Unlike iteration 2's
failure witness, these interactions affect component 1 only. This change is
explicit and was fixed before the iteration-3 calculation.

Each permitted scalar read is Y=F_j(x) XOR E, with fresh independent
E~Bernoulli(1/5). The noise law is known. No final-context observations, hidden
oracle, rereading of observations, or model-specific initialization is allowed.

TRAIN: six blocks, n odd observations each, in order
  (j,b)=(1,0),(1,1),(2,0),(2,1),(3,0),(3,1),
using global context 000 for b=0 and 111 for b=1 and the named scalar port j.
AUDIT: r odd observations of component 1 at 001, followed by r at 110.
FINAL: uniform query from Q={010,011,100,101}, disclosed only after learning.
No context in Q appears in training or auditing. Full vector readout is required.
The richer interface also reports the two interaction diagnoses, gamma_A/B.

The split, family, loss, and permitted audit ports are design assumptions, not
patterns discovered from the final contexts. This is a complete exact synthetic
experiment, not collected robot data or an empirical test on an external corpus.
The noiseless mechanism is the evaluation target; noisy future sensor readings
would define a different loss.

3. IDENTIFIABILITY: WHAT THE TWO AUDITS DO AND DO NOT ESTABLISH

General finite linear statement. Let beta range over all of GF(2)^p. Each
accessible scalar port has a known row a and noiseless response a beta. Let A
contain the observed rows and C the target rows. With arbitrarily repeatable
fresh BSC(eta), 0<eta<1/2, target C beta is uniformly reliably learnable iff
  rowspace(C) is a subset of rowspace(A).
Reliability here means arbitrarily small error with enough repetitions. At
positive noise, it is not a finite-sample zero-error certificate.

Necessity: if containment fails, there is v in kernel(A) with Cv nonzero. The
two mechanisms beta and beta+v induce identical observation laws, but different
targets. Averaging the pair forces error at least 1/2 on a differing target bit.
Sufficiency: repeat each of a spanning set of observed rows, recover its response
by majority with error tending to zero, and use the known linear combinations
to recover C beta. A finite union bound gives uniform convergence. The full
parameter class, fixed known rows, and fresh repeatability matter to this proof.

Here beta=(theta10,theta11,theta20,theta21,theta30,theta31,gamma_A,gamma_B).
Training gives the first six unit rows. The two audit rows are e0+e6 and e1+e7.
Their span dimensions, for no audit, A only, B only, and both, are 6,7,7,8.
Thus two distinct scalar audit types, one from each group on component 1, are
necessary and sufficient for complete coverage of the declared interactions.
Other component ports supply no interaction information. One audit already
helps its own group: two is the minimum for complete coverage, not the minimum
for any useful information. Repetition is needed for reliability under noise.

Auditing two contexts says nothing about arbitrary interactions supported only
on other contexts. Reliable identification within a family and validation of
the family itself are distinct requirements. Section 7 gives a sharp witness.

4. EXACT FINITE RISK WITH A LEARNED BASELINE

Define alpha_A=theta10 XOR gamma_A and alpha_B=theta11 XOR gamma_B. The experiment
observes six theta bits with n repeats each and two alpha bits with r repeats
each. The transform (theta,gamma) <-> (theta,alpha) is bijective. A uniform prior
on the original eight bits becomes independent fair bits in these coordinates.
The prior is a device for a minimax lower bound; mechanisms themselves are fixed.

For odd s define
  e_s=sum_{l=(s+1)/2}^s binom(s,l) (1/5)^l (4/5)^(s-l).
Let e=e_n, a=e_r, and p=e+a-2ea. Store block majorities. Predict F1 in group A/B
using the respective alpha majority, F2/F3 using their local theta majorities,
and diagnose gamma_g as theta_{1,g} majority XOR alpha_g majority. Then:

Final normalized Hamming risk          H=(a+2e)/3
Final complete-vector failure         V=1-(1-a)(1-e)^2
Each interaction diagnosis error      p=e+a-2ea
At least one interaction wrong        G=1-(1-p)^2
Any of the eight mechanism bits wrong M=1-(1-e)^6(1-a)^2

Proof of optimality. The likelihood factors across the eight transformed bits,
and odd-s majority is the unique posterior MAP for each. The posterior bias of
an XOR is the product of its two independent posterior biases, so XOR of their
MAP decisions is the unique gamma MAP. The two gamma groups are independent.
For vector loss, the three queried response bits are independent posterior
coordinates; coordinate MAP also maximizes vector posterior probability. For
full-mechanism loss, the bijection preserves joint MAP. Each displayed rule is
Bayes optimal for its corresponding loss. Its frequentist error is constant
over all 256 fixed mechanisms by complement symmetry. The uniform Bayes lower
bound therefore equals the attained maximum risk, proving each minimax claim.
The joint interface implements the separately optimal prediction and diagnosis
decisions; no claim is made about an additional combined five-bit-vector loss.

Known versus learned baseline. If theta10/11 were supplied exactly, gamma error
would be a. With learned baselines it is p. At n=r=3, e=a=13/125, giving
  H=13/125=.104; V=548197/1953125=.280676864;
  p=2912/15625=.186368;
  G=82520256/244140625=.338002968576;
  M=34845013012442529/59604644775390625=.584602309833.
The known-baseline statement is an explicitly stronger information assumption,
not an uncharged oracle in the implemented experiment. All six local entries
are actually learned and charged. With n fixed, unlimited auditing drives a to
zero, but leaves p tending to e and H tending to 2e/3. More audit samples cannot
erase baseline uncertainty. More baseline samples are required to reduce that
diagnosis floor. This is the central extension beyond the invisible-gamma case.

5. FINITE SAMPLE / DATA / CLOCK / CODE FRONTIER

This frontier is sharp in risk for the specified fixed balanced odd allocation
and blocked access schedule. It is not an optimum over adaptive schedules,
unequal allocations, different ports, or code encodings. The general formulas
above cover any positive odd n,r; the table freezes n=3 so calibration costs
remain visible. Each row includes 18 training samples plus 2r audit samples.

 r  total   Hamming       known gamma    learned gamma   peak states data clock
 1    20    .136000000    .200000000     .262400000          256       8    5
 3    24    .104000000    .104000000     .186368000          384       9    5
 5    28    .088640000    .057920000     .149872640          512       9    5
 7    32    .080448000    .033344000     .130408448          640      10    6
 9    36    .075860480    .019581440     .119508500          768      10    6
13    44    .071667854    .007003561     .109546820         1024      10    6

With no audits and randomized guesses of both alpha bits, H=.236 and each gamma
error is .5. That is the no-coverage baseline, not the r=1 controller row.

Memory theorem for the joint interface. At n=r=3 there are exactly 256 possible
terminal majority vectors. Final predictions over Q recover both alpha bits
and all four theta2/3 bits. Together with both gamma reports they recover the
two theta1 majorities. Thus all eight decisions must remain distinguishable:
at least 256 terminal states. Before the last observation, each of 128 previous
decision vectors combines with three distinct last-block residual majority
functions (constant zero, copy last bit, constant one). These 384 residual
interfaces differ on some common suffix/query and cannot share a state.

A packed register containing completed majority bits and a capped active count
attains the bound. At each block boundary the count is replaced by its decision.
For fixed n=3 and arbitrary positive odd r, the same argument gives joint peak
128*(r+3)/2 states and 256 terminal states. The table uses ceil(log2 peak) data
bits; 256 terminal states require eight logical bits, though the peak register
can remain physically allocated. A separate clock for 0,...,18+2r needs
ceil(log2(19+2r)) bits. At r=3 the generic data-plus-clock implementation uses
14 bits. This is not a proof of the minimum for a fused clock/state machine.

Prediction-only qualification. If gamma reports and full-mechanism identification
are not required, the first two theta estimates can be discarded. Only four
theta2/3 bits and two alpha bits matter. Terminal and peak capacities become
64 and 32*(r+3)/2; at n=r=3 this is 96 peak states, seven data bits. The same
late-block residual proof is tight, and ignoring the first two blocks attains
it. Keeping all 18 mandatory training observations charges the original
schedule; a redesigned prediction-only experiment could avoid those irrelevant
baseline observations. Do not attribute the 384-state lower bound to prediction
alone, or claim that the mandatory schedule is sample-optimal for that task.

Code and work. Both implementations share the compact packed-counter algorithm:
one update per scalar observation and a fixed number of bit operations per
three-bit query. Compilation preserves it; no exponential history table is
required. For an explicit reproducible code charge we also serialize dense ROMs:
8 uint16 header values; B-bit initial state; T*S*2 B-bit updates; S*8 five-bit
readouts; T five-bit context/port addresses; zero padding to whole bytes.
Logical size is 128+B+2TSB+40S+5T. At n=r=3, S=384, B=9, T=24, it is 181,505
bits and 22,689 padded bytes. Both ROMs have the same SHA-256:
  14f6719798a978e3b5f930ff6111f7b12a7cf9c00d7d6aeb7b81b2a5718abc6b
For r=1,3,5,7,9,13 the corresponding dense upper costs are tabulated exactly in
exact-results.json, together with all risk fractions. These ROM costs are
explicit representation-dependent charges, not shortest-program lower bounds.
The small arithmetic implementation is available to both comparator classes.

The resource vector includes all learning/audit samples, retained decisions,
active count, clock, immutable code, and the five-bit output interface. Noise
rate and family specification are shared prior information. No exact real
register or free external estimator is used. The terminal query is an input,
not free persistent memory. A rereadable output log would count as memory.
Hardware scratch, interpreter cost, gate count, physical energy, latency, and
compiler engineering are not measured. Python's process RAM is emphatically
not the stated nine-bit controller register. The verification program is an
offline checker, not a resource-free component of the deployed learner.

6. EXACT CHECKS AND FRESH SKEPTICAL REVIEW

audit_checks.py enumerated all 4^8=65,536 block-count tuples at transformed truth
zero with exact integer/Fraction weights; complement symmetry extends the law.
It checked the formulas, 3,060 reachable transition edges, 384 distinct required
joint residual interfaces, 96 task-only residual interfaces, four audit-coverage
patterns, and 2,048 truth/context cases for the hidden interaction. It generated
the modular and compiled ROMs separately and verified byte equality. Runtime
on this machine was about 0.44 seconds; this is one observed run, not a benchmark.

independent_checks.py imports none of the main checker. It enumerates all eight
three-observation words to recover the majority error, then all 256 weighted
block-error masks for each of all 256 true mechanisms (65,536 truth/mask pairs).
It independently evaluates the final losses and verifies constant risk, parses
the packed ROM rather than trusting generator objects, checks every reachable
edge and all 3,072 readout entries, and independently counts residual signatures.
All checks passed in about 1.36 seconds. This compressed exact computation is
not a claim to have literally enumerated all 2^24 observation strings.

A fresh skeptical AI reviewer independently enumerated weighted masks and
residual interfaces. It accepted the formulas and proof structure, and required
three qualifications incorporated here: the joint versus prediction-only memory
distinction; two audit types for complete coverage rather than any usefulness;
and 1/24 as the hidden bit's loss contribution rather than total risk 1/2. Its
review is recorded in ai-review.txt. AI review and bounded checks support, but
do not replace, expert peer review or a proof assistant. No proof-assistant
formalization or novel-theorem certification is claimed.

7. SHARP LIMIT: AN INTERACTION SUPPORTED ONLY OUTSIDE THE AUDIT

Enlarge the family by one bit delta, adding delta to F1(010) only. It is zero
on every training and audit port; all other responses are unchanged. For each
fixed original mechanism, delta=0 and delta=1 produce identical evidence laws.
Their different final bit at 010 therefore has pair-average prediction error
at least 1/2. Context 010 has probability 1/4 and one of three output components
is affected, so the unavoidable normalized Hamming contribution is
  (1/4)*(1/3)*(1/2)=1/24.
It is an asymptotically attainable floor when the other responses are learned
and that bit is guessed fairly. It is not the complete finite-sample risk.

The nominal learner, which assumes delta=0, has for true delta=1
  H_delta=H+(1-2e_r)/12.
At n=r=3 this is .104+.792/12=.17. All 256 original mechanisms were checked.
Thus the declared two-interaction audit succeeds exactly on its declared
family and can still fail on an unseen interaction. Testing more often at the
same two audit contexts cannot expose delta. A new informative context/port or
a justified structural restriction is necessary.

8. CONNECTION TO HIERARCHICAL CONCEPTS AND BOOLEAN FACTORIZATION

The actual hierarchical-concepts manuscript [6] organizes models by distinctions
available to an observer. Here that becomes a precise observational quotient:
beta and beta' are equivalent when every accessible row gives the same response,
equivalently A(beta-beta')=0. Training alone leaves four interaction mechanisms
per class; one audit leaves two; both identify a singleton in the declared family.
Positive noise changes confidence, not this equality-of-observation-laws test.
Using merely the support of finite noisy transcripts would be wrong: every
transcript has positive probability under every mechanism. Likelihoods matter.

A task can coarsen the required distinctions. The final prediction target uses
only (theta20,theta21,theta30,theta31,alpha_A,alpha_B), whereas the richer report
also needs both theta1 values through gamma. This concretely explains why
coarser task resolution reduces sufficient terminal memory from eight to six
bits without inventing a hierarchy-dependent performance benefit. Observation
quotients, task quotients, and finite-memory approximations are separate objects.

For the factor-only model, the Boolean response relation is
  AND_j [z_j = theta_{j,x_j}],
with disjoint local variable blocks. In the audit extension the first relation
also uses a declared group label and its gamma bit. This is a genuine logical
factorization, but product likelihoods additionally require independent sensor
noise and the stated parameter prior for the Bayes calculation. Boolean
factorization alone does not imply statistical independence or sample savings.
The structured-factorization project page [7] motivates this connection; its
complete theorem note was not obtained, so no claim of reproducing or extending
its mathematical theorem is made. The compiled controller retains the same
factorization. No advantage follows from giving only one comparator access to it.

The physical meaning of theta and gamma comes from the assigned mechanism and
ports. These calculations do not derive semantic self-reference or subjective
awareness from a register name. R4's controlled null [8] remains intact.

9. PRIMARY SOURCES AND WHAT WAS ACTUALLY READ

All access dates in this project are 4 November 2026. Earlier acquisition ledgers
retain raw-file hashes and precise reading depth. Those materials were reused,
not represented as freshly reread in full during iteration 3. The original
162-entry source inventory contains URLs/hashes, not the full source corpus.

[1] Wiedemer et al., Compositional Generalization from First Principles (2023).
https://arxiv.org/html/2307.05596v1
Primary full HTML acquired; Sections 3.2–3.3 and Theorem 1 assumptions A1–A4
closely read in iteration 2. Its differentiability, shared composition,
compositional support, sufficient support/Jacobian, and initial-point conditions
are substantive. Our supplied finite scalar ports do not reproduce that setting.
This is an antecedent for conditional compositional guarantees, not evidence
that the present assumption-free problem is solved.

[2] Schug et al., Discovering modular solutions that generalize compositionally
(ICLR 2024).
https://proceedings.iclr.cc/paper_files/paper/2024/file/6b40b312ce4933f4f2d1ac0b0b6b07f7-Paper-Conference.pdf
Primary 53-page PDF acquired/extracted; Sections 2–3, pp.3–6, informal Theorems
1–2 and discussion read. Its theory has dimensional/nondegeneracy and task
support assumptions. Finite numbers of tasks in a population-loss result must
not be relabeled finite noisy observations per task. Empirical meta-learning is
separate. The appendix was not independently proof-audited.

[3] Rojas-Carulla et al., Invariant Models for Causal Transfer Learning (2018).
https://www.jmlr.org/papers/volume19/16-432/16-432.pdf
https://jmlr.org/papers/v19/16-432.html
Primary 34-page PDF acquired/extracted; Section 2, A1/A1-prime/A2 and adversarial
Theorem 1 closely read. Its distinction between observed source invariance and
assumed test invariance directly motivates keeping our residual interaction
witness. The paper does not supply our finite Boolean audit frontier.

[4] Parascandolo et al., Learning Independent Causal Mechanisms (2018).
https://proceedings.mlr.press/v80/parascandolo18a.html
Primary abstract/metadata only. Learning a mechanism decomposition is a separate
problem from the supplied labels and known port structure in this benchmark.
No detailed theorem comparison is claimed from abstract-only access.

[5] Berg, Shayevitz, Ordentlich, Binary Hypothesis Testing with Deterministic
Finite-Memory Decision Rules (2020).
https://arxiv.org/html/2005.07445v1
Primary full HTML acquired; model/related-work distinctions inspected. Their
long-run time-invariant setting differs from our fixed finite clocked experiment.
Finite-memory testing is established prior work, not a new subject introduced
by these three iterations.

[6] B-Theory, Hierarchical Concepts — actual manuscript.
https://www.b-theory.com/manuscripts-html/hierarchical-concepts/
Observation-quotient/information/symmetry sections inspected. Retrieved hash
matches the inherited inventory. Section 8 makes only the concrete finite
connection justified here.

[7] B-Theory, Structured Boolean Factorization — project summary.
https://www.b-theory.com/structured-boolean-factorization/
Summary acquired and hash-matched; complete theorem note not obtained or audited.
No probability theorem or computational speedup is inferred from the summary.

[8] B-Theory, Reflective Self-Models — actual R4 manuscript.
https://www.b-theory.com/manuscripts-html/reflective-self-models/
Read in iteration 1. The controlled equal-information null and engineering-cost
qualification are retained. An efficient counter comparator was also already
present in the inherited local diagnosis paper; a history-table strawman would
not be a contribution.

[9] Golovin, Krause, Ray, Near-Optimal Bayesian Active Learning with Noisy
Observations (2010; arXiv revision 2013).
https://arxiv.org/abs/1010.3091
New primary abstract/metadata read in iteration 3, not a full proof audit. It
studies adaptive costly noisy tests and EC2 competitiveness. Our fixed balanced
schedule has no such adaptive optimality guarantee. This antecedent is a reason
to avoid claiming a new general noisy-audit methodology.

Established ingredients are majority testing, Bayesian/minimax symmetry,
linear identifiability, residual-function automata bounds, and indistinguishable
alternative mechanisms. The useful candidate contribution is their integrated,
fully specified benchmark with honest learning/audit/resource charges and
matched compiled implementations. A broader novelty claim requires a separate
literature/proof review and access to the missing factorization note.

10. LIMITS, DELIVERABLES, AND VIDEO EXPLANATION

Unresolved boundaries: unknown module identities/dependencies; unknown or
correlated/changing noise; adaptive and unequal sample allocation; the complete
risk frontier below Bayes-capable memory; minimum code and hardware cost; family
discovery; and interactions outside observed support. Temporal repeated noise
already breaks the benefit of repetition in iteration 2. Sensor-mode tracking
was deliberately not developed here. None of these gaps is silently covered
by the exact finite checks.

All iteration-3 deliverables are in:
[local research path omitted]
  report.txt / report.html       consolidated claims, proofs, limits, sources
  audit_checks.py                primary exact checker and two-ROM generator
  independent_checks.py          separate error-mask checker and ROM decoder
  exact-results.json             exact fractions and resource frontier
  independent-results.json       independent check counts and outcomes
  modular-controller.rom         explicit joint-interface transducer
  compiled-controller.rom        byte-identical compiled comparator
  ai-review.txt                  fresh reviewer assessment and qualifications
  acquisition-ledger.json        source URLs/depth and inherited provenance
  provenance.json                prior-file hash preservation check
  README.txt                     replication commands and prior report paths
  deliverable-manifest.json      file sizes and SHA-256 hashes

Earlier report paths (unchanged):
[local research path omitted]
[local research path omitted]
The manifest and provenance ledger support the final preservation claim. No Git
command was used. No publication, external message, paid API, GPU, credential
access, or security change was performed in the research iterations.

Suitable five-minute video: “Learning a rule, then testing where it breaks.”
0:00–0:40: Show the eight vertices of a Boolean cube. Mark 000/111 as training,
001/110 as audit, and the other four as unseen final queries. Explain one scalar
measurement at a time and show six unknown local response switches.
0:40–1:30: Three noisy observations vote on each switch. Show a counter carried
by a modular controller and the identical counter inside a compiled controller.
Both have the same evidence and make the same errors; naming is not an advantage.
1:30–2:30: Add two group interactions. An audit learns the response alpha, while
an interaction diagnosis compares alpha with the learned baseline theta. Show
the XOR diagram: either estimate alone can be wrong. Two .104 error rates give
.186368 interaction error, even though direct final response error is .104.
2:30–3:20: Display the sample/risk table and then the memory distinction: six
decisions for final prediction, eight for prediction plus interaction reports.
Explain that clock and code are separate charges; do not animate nine bits as
the RAM usage of the Python verification process.
3:20–4:20: Place an extra interaction only at 010. Every training/audit result
stays unchanged, but that unseen answer flips. Show why no extra repetitions at
the same ports can reveal it. Label 1/24 as an unavoidable contribution, and .17
as the nominal learner's finite risk in the demonstrated delta=1 case.
4:20–5:00: Close with the justified claim: audits can identify a declared family
while leaving unseen contexts, but cannot certify arbitrary unseen structure.
Show the report/checker links. Avoid consciousness imagery or claims about LLMs.
This is a storyboard and explanation plan; no rendered video is included.

The authorized three-iteration development is complete. Stop research expansion
here and retain this package for review. No additional thread or model run is
required now; optional production or broader theorem work should wait for an
explicitly chosen use or a substantive external critique.