# 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:

```text
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:

```text
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:

1. add three to slot zero, then swap slots zero and one;
2. swap slots zero and one, then add three to slot zero;
3. swap slots two and three; and
4. 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:

```text
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`.