DIVERGE-JET1: Joint Epistemic Trajectory

Status: frozen before implementation or neural results on 2026-08-06.

Decision

The span quotient, pooled MEI1 reader, globally matched MQB1 mentions, and query-conditioned QTG1 all fit their train renderer and fail unseen semantic binding. QTG1 is the terminal isolated-reader result: it reaches 99.905% train complete states but only 23.080% lexical, 0.710% renderer, and 0% composition. No further token/span/pointer reader is authorized.

JET1 tests one different optimization and architecture boundary:

Jointly adapt a capable language backbone and train language grounding, whole-program falsification, tied recurrent state execution, and late query readout under one end-to-end trajectory loss.

This is a bounded post-seal trajectory gate. It does not replace DIVERGE's raw WORLD compiler and does not claim unrestricted reasoning. A pass permits one unchanged HSC1 -> DIVERGE integration gate; a failure closes this synthetic register trajectory and forces the next board to use a broader real-language task rather than another evidence-reader repair.

Architecture

The development backbone is the exact pinned Qwen/Qwen3.5-0.8B@2fc06364715b967f1860aea9cf38778875588b17 text path. The backbone is frozen except rank-8, alpha-16 LoRA in the final four text layers. No MEI1, MQB1, or QTG1 trainable state is loaded.

For each delayed evidence record, Qwen encodes the complete raw renderer once. Ten typed field queries cross-attend to the contextual token sequence and emit categorical distributions for five before and five after register values. A tied differentiable route-plus-delta executor applies each complete candidate program to the predicted before state. Candidate support is scored by complete after-state agreement:

score(c) = log prior(c)
         + sum_register log (1e-6 + < Execute(before, c), observed_after >).

The prior deliberately favors the wrong candidate. A straight-through hard argmax selects one complete candidate program. The forward trajectory applies that one candidate to the persistent state; it never averages fields or action steps across incompatible hypotheses. Soft probabilities exist only for the backward estimator: complete-program agreement has an exact hard forward value and its corresponding soft overlap gradient. The same executor parameters are reused for every action and recurrent step. A learned late query route reads one register from the terminal state.

The complete differentiable path is:

raw delayed evidence
  -> jointly adapted Qwen features
  -> typed before/after distributions
  -> complete-program consistency scores
  -> straight-through whole-program commit
  -> tied recurrent typed-state execution
  -> terminal state
  -> learned late query
  -> answer

The candidate runtime receives candidate action sequences, priors, raw evidence tokens, the initial typed state, and the late query. It receives no gold option, gold terminal state, answer, renderer ID, exact transaction function, regex, numeric parser, or evaluator callback.

Frozen board

Every record has exactly two coherent programs chosen from:

add three to slot zero, then swap slots zero and one;
swap slots zero and one, then add three to slot zero;
swap slots two and three; and
swap slots three and four.

The evidence is generated by the true program while the fixed prior favors the false program at every step. Candidate order is randomized, so position cannot solve the task. Persistent initial states are sampled from a range that remains inside the 128-value domain through depth 24. Training uses only the four frozen MEI1 train renderers and depths 1--8. Evaluation keeps the exact lexical, renderer, and composition shifts unopened to the optimizer and uses depths 4/8/16/24.

The one authorized seed is 202608058800. The budget is:

1,600 optimizer updates;
batch 8 complete episodes;
deterministic depth cycling over 1--8;
57,600 raw evidence records;
one Qwen encoding per record, maximum 128 tokens;
LoRA LR 1e-5, trajectory LR 3e-4;
AdamW betas (0.9, 0.95), weight decay 0.01, gradient clipping at 1.0, 80-update linear warmup, then cosine decay to 10% of each peak LR;
512 complete episodes per cohort and held depth; and
exact treatment, cross-episode evidence-shuffle, and terminal-state-reset evaluations.

The joint loss is fixed before results:

L = L_evidence_state
  + L_program_choice
  + L_terminal_state
  + L_query_answer
  + L_operator_auxiliary.

The operator auxiliary samples all four primitive actions inside the same optimizer update and checkpoint. It is not a separately fitted module or a separate training stage.

Frozen gates

All conditions are conjunctive:

one-step learned primitive execution >=99.9%;
evidence complete-state pair >=95% in every cohort;
complete program-choice sequence >=90% at every cohort/depth cell;
free-running terminal state >=90% at every cohort/depth cell;
late answer >=90% at every cohort/depth cell;
wrong-prior recovery >=90% at every cohort/depth cell;
cross-episode evidence shuffle reduces shifted answer exactness by >=20 points at every held depth;
terminal-state reset reduces shifted answer exactness by >=20 points at every held depth;
no out-of-range state is accepted;
the frozen non-LoRA backbone remains hash-identical; and
candidate-runtime source audit passes.

If the treatment passes, run one HSC1/ULC1 full-composition evaluation and one parameter/training-FLOP-matched dense recurrent control. A synthetic component pass alone is not an architecture claim.

Stop rule

JET1 receives one seed and one frozen budget. No post-result renderer exposure, width, rank, duration, layer, LR, loss, threshold, or seed variant is allowed. Failure closes the synthetic register/evidence trajectory; do not retreat to a fifth isolated source reader. Passing treatment but losing to the matched dense control denies DIVERGE/JET1 inclusion.

Result

Status: closed negative on 2026-08-06. No HSC1 integration or dense control is authorized.

Newton job 743298 completed all 1,600 updates, exactly 12,800 training episodes, 57,600 raw evidence records, and the full 8,192-episode / 16-cell evaluation. The candidate has 2,317,961 trainable parameters: 901,888 Qwen LoRA parameters and 1,416,073 trajectory parameters. It encoded 4,056,405 training tokens, used 8,635,438,080 peak allocated CUDA bytes, and completed in 15m44s Slurm elapsed time. The frozen non-LoRA Qwen state remained hash-identical and the candidate-source audit passed.

Capability fails decisively:

one-step primitive execution is 0/20,000 exact;
complete evidence-state pairs are 0/106,496 across evaluation;
free-running terminal states are 0/8,192;
answers are 280/8,192 = 3.41797%, ranging from 1.7578% to 6.0547% by cell;
complete program-choice sequences range from 0% to 2.34375%;
402 episodes accept nonzero out-of-range mass; and
every one of the 16 cells has exactly the same answer score after cross-episode evidence shuffling as under treatment.

The final train batch has evidence loss 13.5988 versus an uninformative 128-way value loss near ln(128) = 4.8520, primitive loss 12.0900, terminal loss 13.8171, zero evidence-pair exactness, and zero terminal exactness. State reset frequently scores above the learned trajectory. The joint hard straight-through objectives therefore do not merely overfit a renderer: they destabilize source grounding and fail to acquire even the separately trivial typed algebra. The final answer path is effectively source-insensitive.

The frozen stop rule applies. Do not run a new seed, duration, LR, loss weight, renderer curriculum, width, rank, soft/hard schedule, HSC1 composition, or matched dense control. Preserve the accepted exact-host ULC1 result as a mechanics result, but close this synthetic register/evidence route to model-owned DIVERGE. Any future architecture gate must use a broader real-language task and avoid requiring several unlearned discrete interfaces to emerge simultaneously from hard straight-through training.

Report/checkpoint SHA-256 values are d4b81340eff7bae2cd9cf721c20914eeeaead4055fcbc158ada2ee339c112f63 / 7b8ad52ebf7b861e52ad920009b6458d0db2f715e9532083cae397ad60e1e1e6.