ADIDAS — UNKNOWN checkpoints that really resume, and exactly what fairness proves
25 October 2026. CPU / standard-library Python only. No network, GPU, paid
calculation, publication, SYMBIOSE loading or child agents.

OUTCOME
Implemented resumable.py with a separate checked base_monitor.py. It fills an
actual missing consumer operation: a returned UNKNOWN can now be extended from
its endpoint while preserving its original source, all proof rows, cumulative
odd-time/division counters, adaptive cap and boundary-cycle memory.
The scheduler is bounded per invocation; no unbounded computation loop was run.
This removes finite-budget starvation for every source that has a finite
terminal witness. It does not prove all sources have such a witness.

1. CHECKPOINT / APPEND-ONLY CONTRACT
The old certificate is fully verified and must have status UNKNOWN.
resume(old,additional_blocks,new_max_bits) reconstructs boundary memory from its
already certified rows, retains b, x, k, S and cap, then constructs only the new
blocks at x. Old trajectory construction is not restarted from b.
The new total block allowance is old accepted rows plus additional_blocks;
unused allowance from an old bit-blocked invocation is not extra accepted work.
The odd-state bit allowance cannot decrease. New reason fields distinguish
current-bit budget, next-block-peak budget and additional block budget.

verify_extension(old,new) checks both complete certificates, original source,
the digest of the old checkpoint, its accepted-row count and the exact equality
of the new row-prefix to all old rows. Thus resumption cannot quietly change
the original source, forget a checked peak, erase a segment or replace an
UNKNOWN trajectory with another starting integer.
Verification may recheck old compressed rows; this is not a claim of O(1)
incremental verification, storage efficiency or runtime acceleration. The
trajectory constructor itself appends without recomputing the old path.

2. FAIR DYADIC SCHEDULE: FINITE-WITNESS LIVENESS THEOREM
At scheduler stage t=0,1,..., allocate an additional 2^t blocks and increase the
bit budget to at least 2^t. Existing larger bit allowances are retained. Each
stage validates the append-only extension. Our actual fair_schedule(initial,
rounds) runs only the supplied finite number of stages.

Theorem. Suppose the actual trajectory from fixed odd b has a finite certificate
of first descent below b or a repeated block boundary. Let K>=1 be its number
of blocks and B>=1 the greatest bitlength of any odd state through that witness,
including the original source and all intra-block peaks. Then a fair scheduler
started at any verified UNKNOWN prefix of this trajectory finds a terminal
witness by stage
  T=ceil(log2(max(K,B))),
provided that stage is executed. Equivalently T+1 scheduler rounds suffice.

Proof. Validated prefixes cannot pass a terminal event: the base monitor stops
at its first descending boundary or first repeated boundary. If it has not
already terminated at the beginning of stage T, fewer than K witness blocks
have been accepted, so at most K remain. This stage permits at least K new
blocks and a bit allowance at least B. Every remaining entrance and within-
block peak fits this allowance, so no bit-budget stop occurs before the
witness, and no new-block limit is reached before it. Exact block/peak
identities and boundary-cycle bookkeeping therefore return the terminal
certificate. All these are finite integer operations. QED.

K and B here are properties of an assumed finite witness, NOT effective
all-source a priori bounds supplied by the theorem. The theorem says how a
known finite path converts to adequate resources; it does not establish that
such a path exists for every b. Both resources matter: an arbitrarily large
block allowance with a permanently fixed bit ceiling can remain blocked,
as the 4096-bit increasing-run test explicitly demonstrates.

3. WHAT AN INFINITE FAIR UNKNOWN CHAIN WOULD MEAN
Every finite UNKNOWN prefix is an exact prefix of the SAME positive-integer
trajectory. Fairness makes its accepted block count unbounded if it never
terminates: any particular next block is a finite computation with finite
peak, and eventually fits the rising allowances.
If an odd state repeated internally, determinism would repeat a later block
boundary. Each block is finite (v2(x+1) is finite for positive x), and there is
a future pit-stop boundary. The monitor would then return CYCLE. Thus an
infinite fair UNKNOWN chain has no repeated odd states and no source descent.
A sequence of distinct positive integers visits every bounded set finitely
often, so these actual odd states tend to infinity.
The scheduler does NOT rule out this dynamical possibility. It only rules out
mistaking finite resource starvation for that possibility.

Demanding DESCENT for every odd b>1 is equivalent to Collatz, by strong
induction and the immediate descent of even integers. Demanding only DESCENT
or CYCLE still allows nontrivial positive cycles. A repeated boundary is a
sound cycle witness but need not be the earliest repeated odd state. Source1
returns the familiar odd fixed-point cycle, not a descent certificate.

4. BOUNDED INDEPENDENT CHECKS
Reproduction: python resumable.py  (Python without -O).
The file loads only its sibling base_monitor.py; no outside credentials,
network service or scientific runtime is needed.

107 finite source tests;463 verified resumption stages;1024 independently
replayed odd steps. Every completed resumed block list equaled the block list
of a separate non-resumed construction, and direct integer odd-map replay
checked source, counters, peaks and exact first-descent positions.
Five tamperings rejected: changed original source, changed old exponent,
changed parent digest, changed parent row-count, float budget field.

Concrete previously UNKNOWN cases:
-27:15 blocks, highest odd-state size12 bits, first descent after37 odd steps.
  Dyadic stages0..4 suffice; stage3 retains5 blocks before its peak-bit stop,
  and stage4 APPENDS10 blocks to reach the descent. No restart at27.
-63:12 blocks,12 bits, first descent after34 odd steps; stages0..4 suffice.
-2^128-1:81 blocks,203 odd-state bits, first descent after295 odd steps;
  stages0..8 suffice. This is one finite test, not a theorem for all all-ones
  starts or an improved stopping-time rate.
-2^4096-1: a4096-bit cap rejects the very first block's larger odd peak.
  Raising the allowance to8192 accepts that one block (4096 odd steps), then
  a second resume appends the next block (4097 cumulative steps). Both remain
  UNKNOWN at their declared one-additional-block budget. No eventual descent
  claim is made for this large test. The complete original row remains intact.

5. SCIENTIFIC SCOPE / RECOMMENDED SHARING
The mathematical fairness argument is standard semidecision/dovetailing
logic, not a novel Collatz stopping theorem. The useful new deliverable for
our existing consumer is the actual resumable interface and its checked
preservation/liveness contract. This may be shared as an update to the tool
kit; it does not justify a standalone major paper or a claim that the unknown
frontier has been proved empty. No external peer validation was sought here.

Files: resumable.py, base_monitor.py, CHECKS.json and this REPORT.txt.
All recorded jobs have finished. No failure or UNKNOWN was suppressed.

FOLLOW-UP: AN UNCONDITIONAL FINITE-DOMAIN CLEARING BUDGET
The earlier independently verified million-source certificate gives actual
shortcut first-descent time at most176 for every odd3<=b<=10^6. For positive
integers the shortcut map satisfies C(x)<=2x. Since b<2^20, every shortcut
state through that first descent is <2^196. If the shortcut first crossing
falls inside a halving run, all remaining halvings down to its odd endpoint
decrease the value. Hence every ODD state through the first odd descent has
at most196 bits. The number of odd steps, and therefore of compressed blocks,
is at most176. Consequently a call adding256 blocks and an odd-state bit
allowance of at least256 resolves ANY valid UNKNOWN checkpoint in this finite
domain as DESCENT. If an old allowance already exceeds256, retain the larger
allowance to respect resume's nondecreasing-bit contract.
The fair dyadic schedule therefore resolves this entire finite domain by
stage8 (nine stages counted from0), as a consequence of the existing finite
certificate, not a new unrestricted stopping theorem.
Four independent resumption examples27,63,703,837799 passed and were directly
replayed; see FINITE_DOMAIN_CHECKS.json. No million-source sweep was repeated.

API FAIRNESS NUANCE
fair_schedule(initial,rounds) deliberately runs stages starting at0. Repeated
separate calls with rounds=1 would restart at0 and could starve the bit budget.
The infinite-schedule theorem assumes consecutive increasing stage numbers.
A persistent next_stage field is needed to implement that fairness across
separate API calls; the parent is adding such a wrapper. This is a scheduling
contract distinction, not an error in each append-only certificate.
