[0z5a]

Summary

Restructures the October 13 research draft after an external review. It also adds the first accepted 3D solve comparison, run on the transient Ethier–Steinman benchmark. Earlier measured values, gates, seeds and the 15 pinned result reports are unchanged.

Accepted Ethier–Steinman 3D solves (new: research/ethier-3d, paper Section 7)

Frozen protocol v4:

• Unchanged eight gates; 2,000 Adam steps plus up to 400 L-BFGS blocks.
• Six formal seeds (642202–642207). The development seed 642201 is excluded.
• FP64 on two H100 GPUs (Torch 2.4.0a0, NumPy 1.26.4, TF32 disabled). The batch ran once with no retries. The three arms of a seed share a GPU, and arm order is balanced over the six permutations.

Arm	Accepted	Median setup + opt. (s)	Median evaluations	Paired ratio vs C17	Range
FlashNS C17 (17-channel contract, explicit transpose)	6/6	55.7	6,676	1.000	–
A24 (full spatial third-order jet, autograd)	6/6	210.1	7,220	3.602	3.353–4.284
Naive Q35 (35 monomials, autograd)	6/6	386.6	6,675	6.957	6.750–7.436

• The arms need similar evaluation counts. Per evaluation, A24 and naive Q35 cost 3.537× and 7.034× as much as C17 (paired per seed). The ratios measure the contracted state and the explicit transpose together; neither is isolated.
• Pressure relative L2 is the binding gate: max 0.039999 against 0.04. All other gates stay at or below 22% of their limits.
• The independent NumPy audit (Taylor-oracle fields, all qualification gradients, metrics and acceptance decisions) passes 1,512 comparisons over 2,227,032 numbers, with max abs discrepancy 1.78e-14.
• The complete 126-member archive (sha256 1671ffc5…80dd41) is verified on cluster scratch, persistent project storage and locally.
• Scope: both baselines are internal; the network is small (4,740 parameters); C17 is a velocity–pressure contract, not C36. The two GPUs shared a node with another workload; ratios pair arms of one seed on one GPU.
• Public source copies differ from the executed bytes only in a site activation path and a hardware label. release-source-map.json lists both hashes.

2D representation versus execution on H100 (paper Section 5.6, research/2d-ablation)

Purpose. This is a pre-registered ablation answering the review's main 2D question: how much of GL8's speed is the derivative state, and how much is execution?

Cells. All six run the same FP64 Kovasznay objective, the unchanged 2D source at its pinned commit and the unchanged bench_gpu method (fresh process, dense-Q10 oracle check, 7×100 CUDA Graph replays):

Cell	Backend	Execution
A	compact Q10	Inductor
B	compact GL8 with the explicit transpose	Inductor
C	the same GL8	native pointwise kernels
D/E	A/B	eager
F	GL8 with generic autograd	Inductor

Prior evidence. The protocol stated beforehand that A100 had found compiled GL8 no faster than compiled Q10 at 2k points.

Attempt 1 failed at start-up in all tasks, before any timing: the source tree had been copied without git metadata. It is archived. Attempt 2 cloned the pinned commit, with a fail-fast guard; the protocol and plan are unchanged.

Points	A Q10 ms	B GL8 ms	C native ms	A/B representation	B/C execution	A/C total	F/B transpose
2,048	0.282	0.259	0.165	1.09	1.57	1.71	1.03
8,192	1.519	1.126	0.614	1.35	1.83	2.48	1.07
16,384	2.918	1.788	1.172	1.63	1.53	2.49	1.31
65,536	11.422	6.939	4.338	1.65	1.60	2.63	1.31

Validity. 244/244 tasks completed, and the 226 timed processes pass the oracle (≤ 8.0e-15). Drift is within 0.6%. The registered A/A gate passes at 16k (1.0002) but fails at 2k (1.057): processes at 2k fall into two states about 6% apart. That bimodality is a post-hoc observation, not clock-related and unexplained.

Findings.

• Execution. Native pointwise kernels give 1.53–1.83× at every size. GEMM time is identical (cuBLAS; Inductor emitted no GEMM templates).
• Representation. Unresolved at 2k, and 1.63–1.66× from 16k on.
• Explicit transpose. No effect at 2k; 1.31× from 16k on. The contributions list now says so.
• Topology. At 16k, widths 32/128 and 3/4 hidden layers give the same decomposition. At 2k, width 32 makes GL8 slower (0.92×).
• Solves (2k, six formal seeds, 18/18 accepted):
  • C/A setup+opt is 1.16× (0.91–1.40), but optimization alone is 0.95×. A post-hoc phase split shows that each L-BFGS evaluation costs 6.3–7.2 ms, against under 0.3 ms of gradient replay, so the 1.71× faster gradient is absorbed.
  • The setup advantage behind the 1.16× uses warm per-lane compiler caches (see below).
• Records. Published: 2d-ablation-result-20261016.json (registered reader), 2d-ablation-posthoc-20261016.json (labelled post hoc) and release-source-map-20261016.json (all published sources byte-identical to the executed copies).

2D solves at larger point counts on H100 (paper Section 5.6, Table 10, research/2d-solve-scale)

A second pre-registered study tests whether the solve-level gain returns when the gradient is a larger share of each evaluation. The protocol, plan, driver, reader and solve wrapper were committed in 170412b before the batch ran.

• Design. Cells A (compiled Q10), B (compiled GL8) and C (native GL8) solve at 16,384 and 65,536 interior points from the six formal initializations, one fresh process each: 36 solves on one 4-GPU node, run once. These are new problem instances; the network, optimizer program, validation sets and acceptance are unchanged.
• Rule. A solve-level gain needs an optimization-only geometric mean above 1.03 and at least 5 of 6 jointly accepted pairs favouring the faster cell.
• Outcome. All 36 solves are accepted, and the rule finds a gain for every pair at both sizes (6/6 favourable each).

Points	C/A optimization only	C/A per evaluation	A/B (representation)	B/C (execution)
16,384	1.48× (1.31–1.80)	1.43×	1.26×	1.18×
65,536	1.88× (1.75–2.05)	1.95×	1.41×	1.34×

• Predictions. The protocol expected about 1.4× and 2.0× for C/A.
• Why (post hoc). At 2,048, 16,384 and 65,536 points, in every cell, each L-BFGS evaluation costs 5.9–7.1 ms beyond gradient replay; Adam adds only 0.05–0.12 ms. That fixed cost is 22–43× the gradient at 2,048 points and 0.5–1.5× at 65,536. On H100 the solve-level gain is therefore a matter of problem size, not of the device. The 2,048-point explanation, the replay-versus-solve discussion and the conclusion are rewritten accordingly.
• Setup. It depends on per-lane compiler-cache state set by queue order: A takes 22–23 s for a lane's first solve of a size and 4.7–5.9 s later. The ablation's 2,048-point Q10 setups were warm-cache values, so that comparison is warm against warm; warm Q10 setup is still slower than native. At 16k/64k, queue order decided which seeds paid a cold compile, which widens the setup-plus-optimization ranges. The decision uses optimization alone.
• Records. solve-scale-result-20261016.json (registered reader), phase-split-2048-20261016.json and solve-scale-posthoc-20261016.json (both labelled post hoc), release-source-map-20261016.json (12 files byte-identical to the executed copies).

C36 zero-gate folding on H100 (paper Section 6.3, Table 13)

The CPU-only limitation is now closed by a pre-registered batch: protocol, driver and reader were committed in c5de0ad before it ran. It runs once on one exclusive H100 node and uses one GPU, for timing isolation. The unchanged runner and graph-timing protocol run twice, one after the other, on the same GPU: first the folded comparison, then an unfolded repeat.

Run	Analytic	Parameter AD	Ratio	95% interval
Unfolded repeat	166.6 ms	220.8 ms	1.325×	1.3249–1.3257
Folded (both arms)	99.4 ms	139.1 ms	1.400×	1.3999–1.4002

• Checks. Both runs pass all 78 objective/numerator/gradient comparisons (largest error 3.0e-6 of the budget), the NumPy reader and the folding reader. 2,933 of 4,999 rows are active; every row is accounted for, and normalization is unchanged.
• Registered classification. Analytic advantage under folding (interval lower bound above 1.03). The unfolded repeat reproduces 1.324×.
• Folding factor (descriptive). 1.68× for the analytic candidate and 1.59× for parameter AD, against 1.70 for cost proportional to rows (1.74 by 128-row chunks).
• Paper changes. The abstract, the limitations and the conclusion are updated.
• Records. zero-gate-folding-gpu-result-20261016.json and release-source-map-zero-gate-20261016.json. The public driver reads the node-local cache root from the environment; this normalization is recorded in the map.

The H20 campaign on H100 (paper Section 5.8, Table 12, research/2d-h100-retest)

The H20 campaign runs unchanged on one H100 node: the same 460 source/adapter/snapshot files, frozen inputs, six initializations, optimizer budget and acceptance. Pre-registration ffd597e was pushed before submission. The plan was prepared on 10-13 and never ran; only the job name changed.

• Acceptance. All 78 solves are accepted and rechecked by complete CPU scalar AD.
• Variants. Compiled variants won qualification for ED, collapsed Taylor, torch AD, PhysicsNeMo and cuDNN; for example, compiling cut collapsed-Taylor replay from 2.36 to 0.75 ms. cuEquivariance native failed qualification: its fused tensor product has no double-backward formula.

Baseline / GL8	H100 setup+opt (registered)	H100 opt only	H20 setup+opt
Q10 compact	1.22 (1.12–1.39)	1.02	1.66
Collapsed Taylor	1.37 (1.28–1.63)	1.21	1.73
Cao ED	1.29 (1.13–1.42)	1.09	2.31
Torch coordinate AD	1.90 (1.79–2.00)	1.67	2.99
STDE exact	1.69 (1.45–1.88)	1.58	3.37
PhysicsNeMo	1.93 (1.51–2.43)	1.52	3.11
cuEquivariance polynomial	1.49 (1.29–1.94)	1.34	1.56
cuDNN	30.1 (25.9–35.7)	30.4	22.9
GL8 chunk-512	1.10 (1.04–1.31)	1.10	1.42

• Result. GL8 still beats every baseline on H100, but by much less, as the registered expectation said.
• Cause. The supplementary reader (registered before the run) shows that every backend except cuDNN pays 6.3–9.0 ms per L-BFGS evaluation, while the gradient costs 0.24–2.3 ms.
  • In optimization alone, Q10 is level with GL8 (1.02). Its remaining gap is setup: 4.8 s with a warm compiler cache, against 0.3–0.6 s native.
  • The larger H20 ratios are consistent with the gradient's larger share on H20; the H20 L-BFGS cost was not measured. The abstract and conclusion now give the H100 ratios next to the H20 ones; the two are not pooled.
• Memory. The chunk memory trade-off reproduces: an 85% lower setup peak at 16,384 points.

FP64 / FP32 / TF32 on H100 (paper Section 5.7, Table 11, research/2d-precision)

This answers the review's FP32/TF32 request. The protocol, plan, wrapper and patch were committed in dbb6d33 before the batch ran.

• Arms. Compiled Q10 (A) and native GL8 (C) in three precisions.
• Source change. The pinned 2D source accepted only FP64, so a 28-line patch relaxes only its dtype checks. FP64 gradients stay bit-identical.
• Acceptance. Stop checks and acceptance always run in FP64 on the FP64 problem.

Cell	Precision	Replay ms (2k / 16k / 64k)	Gradient error	Accepted (2k / 64k)	FP64/reduced, optimization only
A	FP32	0.183 / 1.573 / 6.004	1.4–2.7e-7	6/6 / 6/6	0.98 / 1.53
A	TF32	0.187 / 1.534 / 5.829	1.5e-4	0/6 / 0/6	–
C	FP32	0.136 / 0.662 / 2.399	1.5–2.7e-7	6/6 / 6/6	0.97 / 1.36
C	TF32	0.117 / 0.640 / 2.282	1.5–2.2e-4	0/6 / 0/6	–

FP64 replay for reference: A 0.281 / 2.920 / 11.440 ms, C 0.164 / 1.165 / 4.343 ms.

• FP32 suffices at these 1–2% gates. All 24 FP32 solves are accepted. Every solve stops at the gates, so tighter accuracy was not tested. At 2,048 points there is no solve gain, because the fixed L-BFGS cost dominates. At 65,536 points FP32 shortens optimization by 1.53× and 1.36×, and GL8 stays 1.67× faster than Q10.
• TF32 fails. 0/24 solves are accepted. Post hoc, L-BFGS makes about one iteration per block, and the final errors stay 10–22× over their limits.
• Records. precision-result-20261016.json, precision-posthoc-20261016.json and the release map. The result's failure tracebacks have their batch path normalized.

External 3D derivative baselines (paper Section 7.4, Table 28, research/ethier-3d)

The review asked for an external baseline on C36. C36 has no accepted solve, so this uses the accepted Ethier–Steinman benchmark; the C36 item stays open. The protocol, external arms and drivers were committed in e2e5108 before the batch ran.

• Arms. Nested scalar-coordinate PyTorch autograd, and Dangel et al.'s public collapsed Taylor-mode jet package. Neither uses FlashNS code.
• Batch. C17 reruns beside them in the same batch and runtime, with the v4 data, seeds, optimizer and acceptance.

Arm	Accepted	Median s	vs C17 (setup+opt)	Adam-phase per evaluation (post hoc)
C17	6/6	47.2	1.000	2.4–2.7 ms
Collapsed jet	6/6	52.6	1.085 (0.98–1.19)	3.6–3.7 ms (1.37×)
Nested torch AD	6/6	89.0	1.901 (1.67–2.14)	8.3–10.1 ms (3.62×)

• Interpretation. Every L-BFGS evaluation adds about 6 ms in every arm, which compresses the solve ratios.
  • Against a strong public Taylor-mode implementation, the paired ratio on this small problem is only 1.08× (0.98–1.19). One seed favours jet, and no gain rule was registered.
  • No arm was compiled. In 2D, each baseline used its faster qualified variant. On the 2D H100 retest, compiling made collapsed Taylor, ED and torch AD replays 3.2×, 5.0× and 2.3× faster, so a compiled jet could match or beat C17 in 3D. C17 is also uncompiled. Compiled external arms remain untested in 3D.
• Audit. It passes 1,512 comparisons, with max error 1.8e-14. All 17 published files are byte-identical to their executed copies.

Compiled 3D external baselines (paper Section 7.4, Table 29) — C17 loses its lead

The question was whether compiling changes the 3D comparison. Pre-registration 7e803c0, pushed before submission. Each method runs graph-only and compiled. Each lane first runs every arm on a development seed without training, and the faster qualified variant on that warm-up replay is selected before any formal solve is read.

• C17 compiled failed CUDA Graph capture in 10/10 attempts. The cause is a recompile that hits an untraceable generator; it was not found. C17 therefore ran graph-only.
• Selected variants. Compiled jet (0.85 ms replay, vs 3.45 ms graph) and compiled nested AD (2.39 ms, vs 9.76 ms). All 30 solves of the five qualified arms are accepted.

Selected external / C17 graph	Setup + opt (primary)	Opt only (secondary)
Compiled collapsed jet	1.05 (0.95–1.24): no decided difference	0.81 (0/6 favour C17): external faster
Compiled nested AD	1.59 (6/6): C17 faster	1.01: no decided difference

• Post hoc. The compiled jet's Adam-phase evaluation costs 0.39× eager C17's. A public Taylor-mode package compiled by torch.compile evaluates the gradient faster than the eager C17 contract.
• Caveats.
  • The cache caveat does not apply.
  • The graph arms reproduce the earlier ratios (1.11, 1.92).
  • C17 has no native execution layer, unlike 2D GL8. A compiled or native C17 is open.
• Paper changes. The abstract, discussion, limitations and conclusion now state this. The uncompiled batch stays in §7.4 as measured.

Compiled C17, second attempt (paper Section 7.4, Table 30)

• Repair. A one-GPU diagnostic, kept under research/ethier-3d/diagnostics and labelled as not a result, reproduced the capture failure for make_fx-based routes. Compiling a function that takes the six parameter tensors as explicit arguments (the 2D engine's pattern) survives capture.
• Attempt 2. Pre-registration b391841: only the C17 builder changes, plus a warm-up gate. All 36 solves are accepted, and every method selects its compiled variant (replay C17 1.20 ms, jet 0.86, nested AD 2.41).

Compiled external / compiled C17	Setup + opt (primary)	Opt only (secondary)
Collapsed jet	1.13 (0.99–1.20), 5/6: C17 faster	0.96 (5/6 favour jet): external faster
Nested AD	1.68 (6/6): C17 faster	1.17 (5/6): C17 faster

• Why the jet decisions differ. The difference is setup. Compiled C17 reuses its compile cache across seeds (3.5–4.0 s). The jet builder recompiles part of its graph in every solve (10.7–10.9 s).
• Per evaluation. The compiled jet is about 5% faster.
• Reading. With all methods compiled, the contracted state gives no per-evaluation advantage over collapsed Taylor mode on this small benchmark. A native C17 remains untested.
• Paper. The abstract and conclusion follow this latest registered decision, as fixed before the attempt. §7.4 keeps both earlier batches.

C36 v2 development run (paper Section 6.7)

The protocol is frozen in protocol-v2-development-20261014.json.

• Only the L-BFGS budget changes, from 20 to 800 calls. Data, model, gates and seeds are as in v1.
• Both engines train both v1 seeds on one 4-GPU H100 node (run once).
• Seeds 361901/361902 were already observed in v1, so this is a development reachability study, not a formal time-to-accuracy claim.

Engine	Seed	Training-gate call	Seconds to gate	Final loss	Final-checkpoint physics
analytic	361901	92	1,014	1.84e-6	fail: stratified pressure 0.0025, endpoint 0.00107
analytic	361902	86	975	1.35e-6	fail: stratified pressure 0.0025 only (endpoint 0.00097 passes)
parameter AD	361901	90	1,319	1.63e-6	partial: stratified pressure 0.0021 fails, uniform passes
parameter AD	361902	85	1,276	2.34e-6	partial: stratified pressure 0.0033 fails, uniform passes

• Training gate: all 4 runs pass it. The original 20-call budget was the limit.
• Development pairing: analytic reaches each loss threshold from 1e-2 to 1e-5 1.30–1.33× sooner than parameter AD. Both arms include the same scheduled dense-AD checks, which bias the ratio toward 1.
• Physics vs v1: every reported physical error falls 7–31× per seed. The uniform gate passes, although only 63 of its 4,096 points lie inside the box. Initial/boundary values and trajectory refinement pass. Stratified corrected pressure (gate 0.001) still fails, largest in the box plateau.
• Registered decision rule: the conditions are (a) "Loss stays above 1e-4", (b) "Loss passes 1e-4 but physical errors stop falling" and (c) "Physical gates pass". The reader's mechanical classification is (b). The later all-plane observations (below) show the errors still falling at the end of the budget, so (b) does not apply either and no branch applies cleanly.
• Observations: one observation takes about 99 min, so this batch observed only final checkpoints, and its time guard stopped the parameter-AD observations after both holdouts. The later observation batches reproduce both analytic rows exactly, complete both partial rows and re-read everything with the independent reader.
• Evidence: reader exit 0, every gradient check within budget (max 1.16e-5 of the original budget). The 295-member archive (266aa8d2…) is verified on cluster scratch and persistent project storage.

C36 all-plane observations and temporal-smoothness continuation (paper Sections 6.8–6.9)

Six new run-once batches ran on single 4-GPU H100 nodes: two smoothness training attempts and four observation batches.

Observations (Section 6.8).

• Every saved v2 checkpoint (52 points, 46 distinct parameter vectors, initial → L-BFGS call 800) plus 26 continuation checkpoints were observed: 72 observations of 72 distinct parameter vectors.
• Each observation covers all data planes: the stratified and uniform holdouts, seven time slices, initial, boundary and both trajectory refinements.
• The independent reader re-reads each one: 8,424 checks, all PASS. The re-observed analytic v2 finals reproduce every metric exactly.
• The observer chunk is chosen by a pre-written calibration rule. Chunk 512 is 3.9× faster than chunk 128, agrees to ≤ 1.8e-11 and peaks at 56.6 GB; the first batch's 50 GB limit kept chunk 128.

Physical acceptance. No checkpoint passes; 171/360 acceptance tests pass.

• The uniform holdout passes from L-BFGS call 200.
• The trajectory endpoint passes at 3 finals.
• Stratified corrected pressure fails everywhere: 1.9–3.3× the limit at the finals, largest inside the moving box.
• The time slices inside the motion window always fail; the slices at rest always pass.

Trend. Physical errors fall with the loss and are still falling at the end of the budget.

• Rank correlation 0.95–0.96 (pressure) and 0.99–1.00 (velocity).
• From call 400 to call 800, pressure falls 0.53–0.83× and velocity 0.48–0.61×.
• So branch (b)'s "physical errors stop falling" does not hold.

Smoothness continuation (Section 6.9, protocol-v3-smoothness-development-20261015.json).

• Family. The motion schedule gets a transition width w: s_w(t) = σ(t/w − 1/(2w) + 1/2). w = 1/2 is the original problem bit for bit.
• Schedules, on the same 4,000 Adam + 800 L-BFGS budget, paired with the v2 analytic runs:
  • C1: w = 1 → 3/4 → 1/2.
  • C2: longer at w = 3/4.
• Attempt 1 failed in all lanes at the Adam-100 dense-AD check. The analytic engine was garbage-collected while its CUDA graph still replayed into its buffers. It is fixed in e9789fb, with a retention check and a weak-reference self-test replay; a negative control without the fix fails the self-test. Attempt 2 changes only the trainer, and all four runs reach the training gate.

Seed	Schedule	Evals to 1e-3 / 1e-4 / 1e-5	Seconds to 1e-4	Final loss	Stratified pressure at gate	Final stratified pressure
361901	baseline	4,042 / 6,039 / 12,129	1,014	1.84e-6	9.73e-3	2.49e-3
361901	C1	2,577 / 5,128 / 9,975	989	1.11e-6	13.1e-3	2.09e-3
361901	C2	6,239 / 6,571 / 12,192	1,246	1.25e-6	5.95e-3	1.93e-3
361902	baseline	4,030 / 5,891 / 10,955	975	1.35e-6	9.41e-3	2.49e-3
361902	C1	2,764 / 5,200 / 9,903	1,003	1.41e-6	11.1e-3	2.77e-3
361902	C2	6,237 / 6,585 / 11,622	1,244	1.32e-6	6.48e-3	2.74e-3

• C1 reaches all five registered thresholds in 8–36% fewer evaluations, but not always in fewer seconds, because each of its two stage rebuilds costs about 65 s.
• C2 is later everywhere in seconds. At the training gate (matched by loss) it is closer to the physics: 0.61–0.69× the baseline's stratified pressure and 0.40–0.45× its endpoint error.
• At the finals the differences are mixed by seed: 10–22%, comparable to the 16–32% spread between the two v2 engines. No schedule changes which acceptance test fails.
• Transfer. The w = 3/4 parameters keep 0.049–0.059 stratified velocity error on the original problem, although the exact fields differ by 0.81. The gate carries the schedule speed and the potential lives in moving-box features.
• Registered rule (quoted in the paper). The continuation does not help. C2 meets the hurts clause through its thresholds; C1 meets no clause cleanly.

Records.

• c36-observations-20261015.json holds every observation with all planes and reader results, generated by tools/c36_publish_observations.py.
• Figure 4 (tools/c36_trend_figure.py) and the rank correlations (tools/c36_rank_correlations.py) are both computed from that record.
• Also published: c36-v3-smoothness-result-20261015.json, c36-v3-smoothness-batches-20261015.json (both attempts), c36-v3-baseline-curves-20261015.json and c36-schedule-field-distance-20261015.json.
• release-source-map-20261015.json: every executed packet manifest. All published sources are byte-identical to their executed copies, except the attempt-1 trainer.
• All archives are verified on cluster scratch and persistent project storage, and all GPU locks were released.

C36 with a larger L-BFGS budget (paper Section 6.10)

Cancelled v4 (protocol-v4-combination-development-20261015.json).

• Design. v4 resumed the C2 and baseline final checkpoints and added 4,000 L-BFGS calls with a fresh history.
• Qualification passed. Start-checkpoint hashes were verified, a tampered start was refused, and each source run's final loss was reproduced bit for bit or within 4.2e-11 of the budget.
• Why it was cancelled. A fresh history at loss ~1e-6 falls into an overshoot/backtrack cycle: 0.2–0.7% loss decrease per 100 calls, against ~32% in the source runs' last 100 calls. The attempt was cancelled after 13.5 min on optimizer progress alone, before any physical observation, and its partial outputs are archived.
• Smoothness arm dropped. The continuation source runs had already stalled at 1.1–1.4e-6 by call 800.

v5 budget study (protocol-v5-budget-development-20261015.json).

• Design. The unchanged v2 recipe, trainer and driver, with the L-BFGS budget extended from 800 to 4,800 calls in one continuous run per (seed, engine); both engines, two seeds.
• Pre-registration. The registered decision (box376.decide_c36_v5, outcomes E1–E5, synthetic tests in CI) was pushed before submission.

Engine	Seed	Loss ×1e6, call 800 → 4,800	Stratified pressure ×1e-3, 800 → 4,800	Endpoint ×1e-3 at 4,800	Failing at 4,800
analytic	361901	1.830 → 1.607	2.40 → 2.36	0.90	stratified
analytic	361902	1.383 → 1.338	2.57 → 2.52	1.00	stratified
parameter AD	361901	1.749 → 1.628	2.26 → 2.17	1.02	stratified, trajectory
parameter AD	361902	1.499 → 1.432	3.03 → 2.97	0.86	stratified

• Training. All 4,800 calls completed within the time guard; all 60 complete-gradient checks pass (≤ 1.1e-5 of the budget). The loss stalls soon after call 800, and no run reaches 1e-6.
• Physics. There were 24 all-plane observations (calls 800–4,800) and the reader passes all 2,808 checks. Stratified pressure changes by under 4% and ends at 2.2–3.0× its limit. The uniform holdout passes everywhere, and the endpoint hovers at 0.86–1.02× its limit.
• Registered outcome: E5. No run passes, and both engines have stopped falling: final pressure is 0.998× its value at 4,000 calls. No formal claim follows. The remaining gap is not a budget limit of this optimizer, so it needs a changed problem definition (sampling, weights or capacity).
• Diagnostics (development only, not a gate).
  • The runs are not bit-identical to v2: they first differ at Adam updates 3–8, a reduction-order effect.
  • Parameter AD needed 1.28–1.36× the analytic engine's seconds per threshold.
• Records. Published records are c36-v5-observations-20261015.json, c36-v5-decision-20261015.json, c36-v5-training-curves-20261015.json and c36-v5-budget-result-20261015.json. The release map lists every executed packet; all sources are byte-identical to the repository.

C36 source structure (paper Sections 6.1 and 6.8; CPU only, no rerun)

A CPU check of the frozen single-box source (box376/check_source_structure.py, output source-structure-check-20261018.json) confirms two properties of the instance to rounding:

• Outside the motion window t ∈ (1/4, 3/4), the exact velocity, force and all their derivatives vanish identically, including at the rest slices t = 0, 1/4, 3/4, 1. Only 0.89% of uniform space-time points carry a nonzero exact velocity.
• Inside the box plateau during the motion, the velocity is affine, U = ċ + Ly, with zero Laplacian. Because L is diagonal, the force f = c̈ + (L̇ + L²)y is a gradient. The rotational forcing lies in the cutoff layers.

Section 6.1 now states both properties. Section 6.8 notes that the four rest slices, which pass at every checkpoint, are slices where the exact velocity and force vanish. No pressure-mechanism claim is made from this.

Where the remaining C36 pressure error lies (paper Section 6.10; CPU post-hoc)

tools/c36_pressure_structure.py decomposes the stratified corrected-pressure error of the four v5 finals from their saved native states. It reproduces every recorded regional and global value exactly. Output: c36-pressure-structure-20261018.json.

• Plateau. Within the motion window the error is 4.4–6.6× the limit. A per-time offset explains 27–70% of it; offset plus a linear term in y explains 64–76%.
• Cutoff layers. They carry 1.2–3.4× the limit. With the plateau error set to zero, they alone would leave 1.5–1.9× the limit, so plateau-only weighting or sampling cannot pass.
• Wider cutoff. At η = 1/16 the layer force RMS is 4–5× smaller and the force-gradient RMS 9–11× smaller. That defines a different, easier instance, not a repair of this one.

C36 v6: a wider-cutoff instance (paper Section 6.11, Table 22; pre-registered in 7671c3f; registered outcome F3)

protocol-v6-eta16-development-20261018.json keeps the v2 recipe and changes one thing: the cutoff width doubles from 1/32 to 1/16. It is a different, easier instance, not a repair of the 1/32 problem.

• Scales. They follow the unchanged rule. The absolute pressure tolerance becomes 9.2e-5, 0.65× the 1/32 value, while the layer forcing falls 4–5×.
• Decision, within this instance only.
  • F1: some run passes, which leads to a formal fresh-seed protocol.
  • F2: near miss, with every limit within 1.5×.
  • F0: incomplete, meaning a run lacks a complete final observation; no scientific reading.
  • F3: fail, with all four finals complete.
• Qualification on CPU.
  • The original calibration generator and its mpmath oracle are now in the repository, byte-identical.
  • The cutoff-width generators reproduce the frozen 1/32 inputs to 2.8e-14.
  • The 1/16 inputs pass the 80/160-digit checks.
  • The geometry agrees with native AD, and the gate is exactly zero at every value point.
• Trainer. The v6 trainer replaces the 1/32 native reference with fresh native AD on a region-covering subset plus dense-AD checks. The stored initial parameters are unchanged.

Results. The batch ran once on one four-GPU H100 node from the git archive of 7671c3f, so every executed source is byte-identical to the repository. Start-up checks pass at ≤ 9.8e-7 of the budget, and all 116 saved checks are within 1.7e-5.

Engine	Seed	Gate (L-BFGS call)	Final loss ×1e6	Stratified pressure / limit	Plateau	Layers alone	Stratified velocity ×1e-3	Endpoint ×1e-3	Failing
analytic	361901	149	4.227	2.89	4.84	2.20	1.81	0.80	stratified
analytic	361902	110	2.767	2.16	3.37	1.73	1.46	0.80	stratified
parameter AD	361901	152	3.490	2.58	4.10	2.04	1.59	0.62	stratified
parameter AD	361902	111	3.002	2.04	3.02	1.67	1.56	1.09	stratified, trajectory

• Registered outcome: F3. No run passes, there is no near miss (best final 2.04× its worst limit), and all four finals are complete. No formal claim follows.
• Final checkpoints. Stratified pressure is the only failing test in three runs. Velocity, momentum, divergence, the uniform holdout and the initial and boundary values pass.
• First training-gate checkpoints. They fail more widely: pressure 9.1–11.5×, endpoint 4.8–9.0×.
• Interpretation. Doubling the cutoff lowered the layer forcing 4–5× but not the normalized pressure error, which stays where it was at 1/32 after 800 calls (2.3–3.0×). The layers alone still leave 1.7–2.2×, so the remaining error is not set by the layer forcing alone.
• Engine timing (development only). Parameter AD needed 1.25–1.34× the analytic engine's seconds to each loss threshold.
• Records. c36-v6-observations-20261018.json, c36-v6-development-result-20261018.json and c36-v6-decision-20261018.json (the last two byte-identical to the executed outputs), c36-v6-pressure-structure-20261018.json and release-source-map-v6-20261018.json. The archive (396 members) is verified on cluster project storage.
• Paper. Section 6.11 and Table 22 are new, and the later tables move up by one. Section 6.10, the discussion, the conclusion and the C36 appendix are updated.
• What drives the pressure error (CPU post-hoc). The exact pressure vanishes, so grad p = R − dI pointwise: R is the observed momentum residual and dI the inertia error of the learned velocity. tools/c36_pressure_attribution.py decomposes the v5 and v6 final states; it reproduces the observer's values and checks the identity to 4e-12.
  • The pressure gradient's cosine with −dI is −0.05 to 0.07 in every region, at the noise floor, so the pressure error is not forced by the velocity error.
  • dI dominates the residual at 3–15× the pressure gradient. The pressure carries 4–11% of the residual energy in the plateau and 0.5–1.3% in the layers.
  • The remaining error is an independent component that the loss weights at about one percent. Reaching the gate needs a term that weights pressure on its own scale, or an optimizer that resolves such a small component.

C36 v7: a dense self-scaled Broyden optimizer (pre-registered in 4e0f669, amended in 72474fb before any run)

The pressure attribution shows that the remaining error is a component the loss weights at about one percent, and L-BFGS stalls before resolving it. protocol-v7-ssbroyden-development-20261019.json keeps the original η = 1/32 instance and the v2 recipe and replaces only the L-BFGS phase.

• Optimizer. Dense self-scaled Broyden (box376.ssbroyden) with an FP64 inverse Hessian (20.6 GB) on the GPU, following Urbán, Stefanou and Pons (J. Comput. Phys. 2025), Eqs. (10) and (13)–(23); they agree with Kiyani et al. (arXiv:2501.16371), Eq. (15).
  • H0 = I; strong-Wolfe line search with c1 = 1e-4 and c2 = 0.9; one dense matrix-vector product per iteration.
  • Unit tests: the textbook BFGS limit, an independent τ/θ/φ computation, the secant condition, positive definiteness, the carried product, and convergence on a quadratic and on Rosenbrock.
• Arms. fresh runs Adam 4,000 and then SSBroyden; continue starts from the v5 analytic finals, with hash-verified starts and a start-loss continuity check. Two seeds each, compiled analytic engine.
• Decision. The v6 outcomes (F1/F2/F0/F3), plus secondary readouts: loss against v5 at matched evaluations, the continue-arm loss ratio, and the post-hoc pressure attribution.
• Registered caveats. Rank-2 updates within one 3 h window see fewer directions than the 50,692 parameters, so a fail is not a verdict on the method at longer budgets. A restart at a loss near 1e-6 can measure the restart itself.
• Self-tests.
  • Unit tests pass in both runtimes.
  • A component test drives the real eager C36 objective through the trainer's callbacks.
  • The driver control flow completes: imports, the start checkpoint is passed, the start loss reproduces the v5 final loss to 1e-8 of the budget, and the reader, decision and archive run.
• Amendment before any run (72474fb). The regular allocation is exhausted, so the batch runs on a 2 h interactive allocation. The training guard falls from 6,600 to 4,000 s and the deadline reserve from 900 to 400 s. The optimizer keeps about 60% of the planned budget (roughly 11,000–13,000 iterations), which is a registered caveat.
• Status. The four-lane H100 batch could not be completed or retrieved, so its two continuation arms were never run. The fresh arm was then registered and run separately on GH200; see the next section.

C36 v7 on GH200: two fresh development runs (paper Section 6.12, Table 23; pre-registered in c34ed33; registered outcome F1)

The optimizer, trainer, 4,000 s guard, reader and rules are unchanged; the decision covers these two runs. A platform qualification first compared eager, compiled and graph objectives with the preserved full native reference and with dense parameter AD (32 comparisons, at most 2.3e-6 of the original budget) and allocated the full inverse Hessian.

Seed	SSBroyden iterations	Final loss	Stratified pressure / limit	Uniform pressure / limit	Stratified velocity / limit	Endpoint / limit
361901	14,412	2.9e-13	9.9e-4	1.1e-4	5.9e-5	3.2e-4
361902	14,637	1.7e-13	9.5e-4	1.3e-4	4.6e-5	2.1e-4

• Both final observations pass every physical test. Stratified pressure, which every L-BFGS run failed, is about 1e-3 of its limit. The registered outcome is F1. A separate CPU readback of the archive recomputes it.
• Checks. There were no resets or skipped updates. All saved complete-gradient checks are within 5.3e-5 of the budget, and the carried inverse-Hessian product agrees with an explicit one to 1.5e-10.
• Registered secondary readout. Evaluations to each loss threshold relative to v5 are 1.00 at 1e-3, 0.71–0.73 at 1e-4 and 0.26–0.30 at 3e-6. v5 never reaches 1e-6. These are counts on different hardware, not a time ratio.
• Limits. The gate-first observation was skipped by the observation budget, so this batch does not show when acceptance was first reached. Both seeds were seen before, so these are development runs.

C36 formal time-to-accuracy cohort (paper Section 6.13, Table 24; pre-registered in 5083508; registered outcome: not qualified)

Five previously unused seeds ran as independent one-GPU GH200 jobs. Each run is inspected first after 1,000 active training seconds, and again at the guard if it does not pass. TTA runs from trainer entry to the first passing physical report, and a pass is valid only after an independent CPU audit of the sealed archive.

Seed	First inspection (active s)	Candidate TTA (s)	Stratified pressure / limit	Frozen audit
1212382065	1,003	5,491	0.267	failed
392322075	1,004	5,581	0.229	failed
422010988	1,004	– (cancelled during its observation)	–	not run
1127789372	1,003	5,228	0.215	failed
949592700	1,003	5,319	0.206	failed

• Physical. All four completed observations pass physical acceptance at the first inspection. About 1,006 s of each TTA is training and 3,092–3,217 s the observation.
• Audits. All four frozen audits fail at audit_c36_tta.py line 206, an allclose(rtol=1e-10, atol=1e-13) on the spatial residual gradient recomputed on x86 against the value saved on the ARM GPU host.
• Registered outcome. COHORT_NOT_FULLY_QUALIFIED: 0/5, Wilson 95% interval 0–0.43, no median.
• Post-hoc diagnosis (CPU; tools/c36_tta_audit_rounding.py). The array sums terms up to 1.4e5 that cancel to about 1e-2. Every difference is at most 4 ulp of the largest term and within the standard rounding bound, at most 0.13 of it. The cause is the auditor's tolerance, not the physics. This does not change the outcome. A qualified cohort needs a new registration with fresh seeds and a tolerance scaled by the summed terms.
• Records. c36-v7-gh200-development-result-20261021.json, c36-v7-gh200-decision-20261021.json, c36-tta-cohort-20261021.json (from tools/c36_tta_publish.py) and c36-tta-audit-rounding-20261021.json.

Second C36 TTA cohort (paper Section 6.14, Table 25; pre-registered in 1fd2bc6; registered outcome: qualified, 5/5)

The second cohort changes only three things: five new seeds (the v1 SHA-256 rule with a new label, excluding every seed seen before), a new holdout seed, and auditor revision 2 (box376.audit_c36_tta_v2).

• Auditor bound. The four summed raw arrays must agree within the a-priori bound 2*gamma_16*sum|terms|; the metrics built from them use the bound implied by the triangle inequality. Every other check is unchanged.
• Validation before registration. Revision 2 passed end to end on the four complete v1 archives (audit-v2-development-validation-20261021.json), with margins of 0.08 and 0.0014 of the bound. This is development use; the v1 outcome is unchanged and nothing is pooled.
• Tests. test_audit_tta_v2 adds five CPU tests, also in CI.

Seed	First inspection (active s)	TTA (s)	Stratified pressure / limit	Independent audit
2013091829	1,003	6,019	0.220	pass
1342776288	1,003	5,074	0.297	pass
8730574	1,003	5,772	0.223	pass
1790307490	1,003	4,825	0.250	pass
2126574302	1,003	5,074	0.191	pass

• Outcome. All five pass physical acceptance at the first inspection, and all five audits pass: FORMAL_COHORT_PASS, 5/5 (Wilson 95% 0.57–1).
• Time to verified accuracy. The median is 5,074 s and the range 4,825–6,019 s, on one GH200. About 1,006 s is training and 2,612–3,757 s the native-AD physical observation.
• Scope. There is no baseline, so this is an absolute time under the registered inspection policy, not a speedup. Record: c36-tta-v2-cohort-20261021.json.

Paired C36 engines to verified accuracy (paper Section 6.15, Table 26; registered in aaea603; outcome: analytic faster)

Five new seeds, each running the analytic and the parameter-AD engine one after the other on one GH200, in alternating order. Each arm stops at a training loss of 1e-8, and its threshold checkpoint is verified physically. A short qualification run on a development seed measured per-evaluation ratios of 1.25 (Adam) and 1.21 (SSBroyden), giving the registered prediction of 1.23 (1.18–1.28).

Seed	Analytic (s)	Parameter AD (s)	Ratio
1344954027	1,025	1,280	1.249
164034124	1,010	1,262	1.250
2110545488	967	1,210	1.252
911819800	991	1,254	1.266
1176150139	1,028	1,305	1.269

• Acceptance. All ten arms reach the threshold, pass physical acceptance and pass the independent audit. The registered outcome is ANALYTIC_FASTER: 5/5 pairs, geometric mean 1.257, inside the prediction.
• Mechanism. Evaluation counts match (0.99–1.01), so the gain is per evaluation. It is smaller than the 1.32 gradient-throughput gain because the dense SSBroyden work is shared by both engines.
• Audit note. The first audit submission stopped at argument parsing before any check ran; the wrapper passed three hashes as one argument. That record is kept, and the audits then ran once with correct arguments.
• Record. c36-pair-cohort-20261021.json.

Manuscript (research/manuscript/flashns.tex, flashns.pdf, now 35 pages)

• Abstract cut to about 180 words; explicit four-item contribution list; terminology table (Q10, GL8, chunk-512, C36, parameter AD, native coordinate AD, replay, solve).
• New related-work section with five additional references, each checked against the publisher or proceedings page: Forward Laplacian (Nat. Mach. Intell. 6(2):209–219, 2024), Taylor-mode AD in JAX (NeurIPS 2019 workshop), Griewank & Walther (SIAM 2008), NSFnets (J. Comput. Phys. 426:109951, 2021), Neural Conservation Laws (NeurIPS 35, 2022).
• TikZ method figure (forward closure and complete reverse transpose).
• New subsection on what the 2D solve times measure: the relative L2 error of v is the binding gate for all nine methods, and stop-check granularity is at most about 0.4% of GL8's evaluations.
• Clarification from the raw protocol: the appendix closure counts include the 4,000 Adam evaluations, so every accepted 2D solve stops during L-BFGS after 2,208–5,259 L-BFGS evaluations. The solver sources match the original 460-file H20 manifest.
• Diagnosis of the failed C36 acceptance:
  • the two engines reach nearly identical losses, about 5× above the gate;
  • 438–449 L-BFGS evaluations on 50,692 parameters;
  • the stratified corrected-pressure error is 6.4–8.7× the uniform value, while the velocity error is larger on the uniform holdout.
• Slurm, lock, archive, compiler-adapter and legacy native-AD records moved to an appendix.
• The two pgfplots plots are now plain TikZ. The PDF builds with pdfLaTeX on stock TeX Live 2020: three passes, no errors, no overfull boxes.
• New Sections 6.8–6.9 and Figure 4. Section 6.7, the discussion, the conclusion and the C36 appendix are updated where they said the trend could not be evaluated or that the metrics had not been re-read independently.

Repository

• evidence-index.json: new tex/pdf hashes, with the previous hashes kept.
• C36 README: replace the stale "GPU results for this protocol are pending" line.
• README: naming table (Q10/Q20, GL8, C36, C17/A24, B1, U/F, B1+/F+, G1/G2).
• scripts/verify_evidence_index.py: stdlib-only check of the 17 pinned files.
• .github/workflows/cpu-regression.yml: evidence-hash job, package tests and the C36 CPU regression tests (25 after adding box376.test_schedule_family).
• The evidence index now pins 48 files, including the 2D ablation protocol, plan, results and release map, the v3/v4/v5 protocols, the observation records and the v5 decision.
• CI runs the C36 CPU regression with 36 tests, including the v4 and v5 decision tests.

History note (2026-10-18). The branch history from the C36 zero-gate pre-registration onward was rewritten to remove an account-specific path from one line of the pre-registered driver. Every rewritten commit keeps its author, committer dates and tree, except that line; commit SHAs cited here and in the release maps are the rewritten ones.

Test plan

• Paired cohort: CPU fixtures for both engines (threshold stop, missed threshold, reader hashes, finalizer) and decision tests; qualification run passes; 5/5 jobs COMPLETED with locks free and no GPU apps; 5/5 audits pass; pdfLaTeX at 48 pages (pages 1 and 34 rendered and read); verify_evidence_index.py: 170 files, 0 failures.
• Second TTA cohort: 5/5 jobs COMPLETED, original GPU locks free with unchanged inodes and no GPU apps left; 5/5 independent audits pass; pdfLaTeX at 47 pages (pages 1 and 30–33 rendered and read); verify_evidence_index.py: 156 files, 0 failures.
• Second TTA cohort: C36 CPU regression 57/57 including test_audit_tta_v2 (x86 host); auditor revision 2 passes end to end on the four complete v1 archives; verify_evidence_index.py: 155 files, 0 failures.
• v7 GH200 and TTA (paper Sections 6.12–6.13): public records generated from the sealed archives, with every member hash checked; rounding diagnosis on all four completed observations; pdfLaTeX (TeX Live 2026) at 46 pages with no overfull boxes or undefined references; verify_evidence_index.py: 147 files, 0 failures.
• python scripts/verify_evidence_index.py: 17 files, 0 failures. A tampered pin fails with exit 1.
• C36 CPU regression: 19 tests pass locally (Torch 2.14.1, NumPy 2.5.4).
• pdfLaTeX build. Figures 1–3 were rendered and inspected.
• Ethier v4 driver self-test (CPU, local and cluster runtime). The 18-case GPU batch completed with all children exiting 0 and the audit passing; the evidence index now pins 21 files.
• Package tests on CI: 233 passed, 2 skipped. After that first green run the step is now blocking.
• C36 CPU regression on CI: 19 tests OK (25 with the schedule-family tests from 6393255).
• verify_evidence_index.py: 48 files, 0 failures.
• 2D ablation: CPU shape tests (torch 2.12 and 2.14), four-lane driver self-test; 244/244 GPU tasks, oracle ≤ 8.0e-15; A/A gate failure at 2k reported as registered.
• v3 trainer CPU self-test COMPLETE (10 checks, including three post-churn retention checks); the negative control without engine retention fails at stage0-retained.
• All 72 observations re-read by the independent reader (PASS). Figure 4 and the rank correlations were regenerated from the committed record and match.
• pdfLaTeX build at 35 pages; Tables 8–9 (Section 5.6), Figure 4, Sections 6.8–6.10 and the appendix were rendered and inspected.
• v4 and v5 trainer/driver CPU self-tests (v4: tampered start refused, observer index aligned; v5: four lanes, no in-batch observation, archive verified). Decision tests 11/11.
• v5: 24 observations re-read by the independent reader (PASS); decide_c36_v5 outcome E5.
• Solve-scale: four-lane driver self-test on CPU stubs. Before submission, the real wrapper was checked under the runtime: imports, the protocol patch taking effect inside the solve path, and no point-count guard in the solver. 36/36 solves were accepted and the archive was re-read.
• Zero-gate batch: login-node self-tests (full stub run, control-skip branch, admission failure still archives and releases the lock); in the real runtime, the runner imports and 4 folding regressions pass. On GPU, 2 × 78 comparisons pass and the archive is re-read.
• Precision: patch CPU check in both runtimes (FP64 bit-identical, FP32 ~1e-7); driver self-test with 162 stub tasks; reader exercised on synthetic results.
• 3D external: CPU qualification against scalar AD (≤ 1.4e-4 of budget); driver self-test with 18 CPU smoke cases, which caught and fixed a stale jet cache keyed on object id; audit PASS.
• Retest: fresh hash checks of 533 ready, 765 runtime and 460 source files in the new root; supplementary reader exercised on synthetic data before the run.
• Compiled 3D: CPU preflight of all three compiled paths against scalar AD before and after an in-place update. Self-test: 60 smoke cases, audit and reader pass, home caches unchanged.
• Attempt 2: self-test with 60 smoke cases (gate empty, audit and reader pass).
• Pressure attribution: reproduces the observer's regional momentum and pressure values (≤ 6.2e-13) and both identities (≤ 3.5e-12) for 8 final observations; pdfLaTeX at 43 pages (page 30 inspected); verify_evidence_index.py: 124 files, 0 failures.
• v6 batch: driver COMPLETE with reader 0 and decision 0, archive members re-read; pressure post-hoc reproduces every recorded value; pdfLaTeX at 43 pages (pages 29–30 inspected); verify_evidence_index.py: 121 files, 0 failures.
• v6 pre-registration: decision tests 6/6; component self-tests pass in Torch 2.12 and 2.4; driver control flow, reader, decision and archive complete on the login node (the login node ends the full CPU trainer self-test); verify_evidence_index.py: 115 files, 0 failures.
• Pressure post-hoc: exact reproduction of all recorded regional and global values for 8 observations; pdfLaTeX at 42 pages (page 28 inspected); verify_evidence_index.py: 104 files, 0 failures; CI green on the rewritten head.
• Source-structure check on the cluster runtime (NumPy 2.4.6): all three properties pass, and source.py hashes to the provenance value. pdfLaTeX build at 41 pages; pages 17 and 23 were rendered and inspected. verify_evidence_index.py: 102 files, 0 failures.
• pdfLaTeX build at 41 pages (Tables 24–25 and the 200-word abstract inspected); verify_evidence_index.py: 100 files, 0 failures. Earlier: 40, 39 and 37 pages; verify_evidence_index.py: 64 files, 0 failures. Earlier: 36 pages after the setup wording fix; Section 5.6 with Table 10, the discussion and the conclusion were rendered and inspected. verify_evidence_index.py: 58 files, 0 failures.

New GPU experiments: the Ethier v4 batch, the C36 v2 development batch, two v3 smoothness training attempts, four all-plane observation batches, the cancelled v4 combination attempt, the v5 budget training and its observation batch, the 2D H100 ablation (attempt 1 failed at start-up; attempt 2 complete), the 2D H100 solve-scale study (36 solves, run once), the C36 zero-gate folding batch (one H100, run once), the 2D precision study (162 tasks), the external 3D baselines (18 solves), the 2D H100 retest under the H20 protocol (131 attempts, 78 accepted solves), the compiled 3D external baselines (24 warm-ups, 36 solves), a one-GPU compile diagnostic, the second compiled attempt (24 warm-ups, 36 solves), the C36 v6 wider-cutoff batch (4 runs, 8 observations), a one-GPU GH200 platform qualification, the C36 v7 GH200 fresh batch (2 runs, F1) the first five-seed GH200 TTA cohort (not qualified), the second (qualified, 5/5), a one-GPU pair qualification, and the paired engine cohort (analytic faster, 1.257). No external C36 baseline is claimed.