R12 Task-Quotient Lifting CPU Preregistration

Status: FROZEN 2026-07-15 before any committed board artifact, model fit, score, or GPU execution. This package authorizes only deterministic CPU generation and independent admission audit of the finite falsifier specified below. It does not authorize a Shohin fit or a capability claim.

Claim status: no novelty claim, no reasoning claim, no context-compression claim, and no learned-sufficient-state claim. The finite analytic reference is a known linear sufficient statistic supplied as a positive control.

1. Task-conditioned theorem object

Let T be a task contract, X a context, Q a future query drawn from the declared support of T, and Y=f_T(X,Q). Define

x ==_T x'  iff  f_T(x,q)=f_T(x',q)
                   for every q in support(T).

The exact task quotient is R_T(X)=[X]. Any fixed-length exact state S that answers every declared query without reopening source information must refine this quotient. Therefore

b >= ceil(log2 |range(R_T)|).

For a distributional prefix code, expected state length is at least H(R_T|T). Under expected task loss ell, the approximate information limit is the task-conditioned rate-distortion function

R_T(D) = inf I(X;S|T)
         subject to E[ell(Y,g(S,Q,T))] <= D.

These are lower bounds and specification objects. They do not imply that a 125M model can discover or execute the quotient.

2. Reversible archive and retrieval bounds

The proposed accounting object is a deterministic reversible factorization Phi_T(X)=(S,A) with H(X|S,A,T)=0. When both outputs are deterministic functions of X, exact reversibility gives

H(A|S,T) = H(X|S,T)
H(S,A|T) = H(X|T).

Thus task quotienting can reduce active state, but cannot losslessly compress arbitrary context below source entropy. Every discarded distinction remains in the archive.

For a prefix-free retrieval transcript Z, all payload, address, call count, order, and timing channels are charged. If an answer over alphabet Y has error epsilon, Fano's inequality and data processing require

E[bits(Z)] >= H(Y|S,Q,T)
              - h2(epsilon) - epsilon log2(|Y|-1).

For retrieval steps Z_1,...,Z_k, define ambiguity debt

D_i = H(Y|S,Z_1,...,Z_i,Q,T).

Then

D_(i-1)-D_i = I(Y;Z_i|S,Z_<i,Q,T)
             <= H(Z_i|S,Z_<i,Q,T).

The equality is distributional: realized posterior entropy may rise on a surprising packet, but expected debt cannot fall by more information than the retrieval transcript carries. Model parameters are a shared program and are never counted as episode-specific context bits.

3. Exact novelty and equivalence boundary

The quotient is functional compression / graph coloring. Minimal relevant state is information bottleneck and sufficient-statistic learning. Sequential future state is predictive-state or approximate-information-state territory. Layered refinement is successive refinement. Choosing reads by expected information gain is active feature acquisition. Reversible context memory and hierarchical compression also have direct precedents.

Consequently, neither the quotient, the archive, uncertainty, nor their combination is claimed as a new primitive. A future learned implementation would have to be compared against information bottleneck, functional compression, predictive-state representations, active acquisition, ordinary retrieval, raw replay, recurrent summaries, and reversible-memory controls.

The present GF(17) reference is exactly a finite-dimensional linear sufficient statistic. It is not evidence of neural discovery, reasoning, semantic understanding, length generalization, or a resource separation.

4. Frozen Q-LIFT finite-field task

The world is z in GF(17)^6. Each case samples an invertible public basis C in GF(17)^(6x6). The task projection P is the first two rows of C, and the exact active state is

s = P z in GF(17)^2.

There are exactly 17^2=289 task quotient states, so the exact fixed-state lower bound is

ceil(log2 289) = 9 bits.

In transformed coordinates y=Cz, every context event has form

y' = [B 0; K D] y + [c; d].

Therefore s'=B s+c is closed and independent of kernel coordinates. The generator converts the event back to world coordinates and records both forms. The auditor independently checks P A = B P and P b = c for every event.

There are exactly 32 base cases: eight each at context lengths 4, 8, 16, 32. Every case has:

• one in-family query after one additional quotient-preserving affine event;
• one out-of-family linear query whose coefficient vector is outside rowspan(P);
• the exact final world, exact quotient state, and fixed 9-bit state code;
• an exact reversible archive of the initial vector and every event.

In-family evaluation is root-only and charges zero retrieval bits. The finite reference answers the out-of-family query only after reconstructing the world from the archive. This package makes no selective-retrieval efficiency claim.

5. Archive and transcript accounting

Each source record is canonical ASCII JSON, base64-encoded in a packet with a consecutive integer address, byte length, and SHA-256 digest. Reconstruction must recover the complete structured context exactly and re-encoding must be byte-identical.

For N packets:

payload_bits = 8 * sum(packet_payload_bytes)
address_bits_per_read = max(1, ceil(log2 N))
full_retrieval_bits = payload_bits + N * address_bits_per_read.

The retrieval-only reference reads every packet in canonical order. It receives no discount for deterministic addresses, ordering, or packet count. There is no hidden source mount, cache, pointer, verifier, solver, or uncounted replay.

6. Frozen controls

The CPU package contains the following controls, each with eight paired witnesses unless stated otherwise:

• Analytic quotient: exact Pz, 9 active bits, no in-family reads.
• Sham projection: rows 3-4 of the same basis, same dimension and readout.
• Capacity-matched prefix copy: the first two raw field coordinates have exactly 289 possibilities and therefore the same 9-bit fixed capacity as the quotient. Paired contexts share this prefix but have different task answers.
• Retrieval-only: no sufficient active state; reconstruct the whole source and pay every archive bit.
• Merge: different kernel histories with the same quotient must have the same declared behavior.
• Split: a one-coordinate quotient perturbation must have a separating declared query.
• Archive swap: root-only answers follow retained state while an explicitly reopened out-of-family answer follows the substituted archive.
• State swap: with archive fixed, root-only answers follow substituted state.
• INDEX: exhaustive n=8 witnesses pair every 7-bit prefix with two source strings separated only at the eighth bit. The exact all-coordinate state lower bound is eight bits.

The copy and sham controls falsify only those exact baselines. They do not prove that every possible copying or retrieval scheme fails.

7. Frozen seeds and digests

case   = 2026071521
merge  = 2026071522
split  = 2026071523
copy   = 2026071524
swap   = 2026071525
INDEX  = 2026071526

The canonical content object consists only of cases and controls:

content SHA-256 = b08ab33faabe15aa09fad0b6abfa1cc94e423c3bd6447de55f547d1312d02165
board SHA-256   = 06ea09988dd2b1f84d5cc2ee5baa6e0a8bc1ea0102c3ba325d371af1929dc376

The generator and auditor must reject any other digest. Output creation uses O_EXCL, refuses symlink replacement where supported, fsyncs the descriptor, and removes all write bits. Existing outputs are never overwritten.

The auditor does not import the generator. It checks the frozen digest and independently recomputes field dimensions, ranks, event closure, world and state trajectories, in/out answers, archive reconstruction, every bit count, all paired controls, all INDEX collisions, and all reported metrics.

8. Absolute CPU admission gates

The exact frozen reference metrics are:

analytic quotient:       32/32, zero retrieval bits
capacity-matched copy:    0/32 on the zero-fill baseline
sham projection:          2/32
retrieval-only:           32/32, 863144 charged transcript bits
merge witnesses:          8/8
split witnesses:          8/8
copy collision witnesses: 8/8
archive/state swaps:       8/8
INDEX collisions:        128/128

Admission requires all of the following:

1. exact board and content digests;
2. canonical, immutable, regular-file inputs and exclusive immutable outputs;
3. all 512 frozen event/future-event closure checks;
4. exact quotient/world agreement for every case;
5. exact context reconstruction and complete address/payload accounting;
6. every merge, split, copy, swap, and INDEX witness;
7. exact independent recomputation of the metrics above;
8. no accelerator framework, subprocess execution, model checkpoint, fitting, optimization, or GPU path.

One mismatch rejects the board. Passing admits only this CPU falsifier.

9. Explicit no-go claim

TQ-Lift cannot provide bounded lossless compression of arbitrary contexts. Exact arbitrary late INDEX over n independent bits requires n retained bits when memory is sealed; with average bit error epsilon, at least n(1-h2(epsilon)) bits are required. Longer computation and fixed model weights cannot recreate discarded episode-specific information.

With reversible memory, total state plus archive still carries the source entropy. The only admissible scaling claim would be a reduction in active state or expected charged retrieval for a declared task distribution whose quotient has low entropy. This finite package neither establishes that condition for natural language nor shows that Shohin can learn it.

10. Decision

This version is a frozen mathematical accounting and adversarial-control package. It may be generated and audited on CPU. It does not authorize model training, GPU use, board tuning, seed search, threshold search, artifact shopping, or any statement that TQ-Lift is novel or that Shohin has acquired a reasoning or context-scaling capability.