@@ -5,6 +5,7 @@ compared to earlier versions.
 
 | Differing behavior | commit hash / tag and timestamp | Summary |
 | ---------------- | ------------------------------- | ------- |
+| Y | 2026-10-20 | Accelerate the standalone full-orbit Gauss-2 energy/oracle evaluator with exact coefficient sparsity, shared recurrent Fourier phases and FortSym-generated field/Hessian contractions. The algebraically equivalent factored Hessian can change roundoff; orbit length, seeds, step policy, tolerances and energy checks are unchanged. |
 | Y | 2026-10-20 | Keep classifier surface Bmin/Bmax per particle. Multi-surface OpenMP classification plots now retain the serial trapped-passing boundary in `fort.20000`; particle classification and loss accounting are unchanged. |
 | N | 2026-10-16 | SIMPLE no longer imports the IEEE intrinsic modules; `finite_check` provides `is_finite` and `quiet_nan`. gfortran saved and restored the floating-point environment in every procedure with a local `USE` of a module whose dependencies imported IEEE, including `velo_can` and `integ_to_ref_albert` in the tracing loop. Albert-coordinate tracing is about 1.2x faster; outputs are byte-identical. |
 | Y | 2026-10-16 | SPECTRE hybrid tests the full-orbit exit distance once per radian of gyration and at the end of each microstep instead of after every RK45 substep (about 40% of full-orbit time). Exits occur up to 1 rad later; FO-everywhere orbits are unchanged. See `concept/spectre_loss_study/results/profile/`. |
 
@@ -379,6 +379,31 @@ $N_\text{fp}$, `fper` $= 2\pi/N_\text{fp}$ and `rmajor`, the $m = n = 0$
 harmonic of $R$ on the outermost interface (m), so that `params_init` derives
 $\Delta\tau$ as for VMEC.
 
+The canonical Gauss-2 full-orbit evaluator in
+`concept/fo_symplectic_proof/spectre_fo_gauss2.f90` retains the same smooth
+embedding and vector potential. It caches field-constant angular factors and
+shares radial profiles between Fourier modes. Preparation packs the nonzero
+potential coefficient tuples without changing their mode/degree order; an
+identically zero interface gauge is skipped as a whole. FortSym emits the fixed
+geometry contractions and the two-component potential accumulation. The field-jet
+call passes geometry's Fourier phases to the potential at the same point,
+avoiding a second trigonometric evaluation. The internal metric path constructs
+integer Fourier harmonics by complex-product recurrence from two fundamental
+phases; FortSym proves the addition identities and emitted expressions. Sparse
+high harmonics retain direct trigonometric evaluation. The public geometry
+helper retains direct phases for the bitwise frozen-provider oracle; the hot
+path also has an independent phase roundoff check and the Hamiltonian/map
+oracles. Predictor and residual-only
+stage evaluations request first-order field jets and a FortSym-generated
+Hamiltonian leaf without Hessian outputs, including first-order radial-metric
+and monitor leaves without unused second derivatives; Newton corrections and tangent maps
+use the complete jets. The full Hessian uses the factored inverse-metric
+identity generated and checked by FortSym; energy and force retain the original
+first-order expressions. The generated array interface binds the scalar DAG
+directly to arrays. Small stage evaluations run serially. Energy tests reuse
+H at the next step's start and evaluate the final endpoint explicitly, retaining
+the energy envelope and drift diagnostics at every accepted step.
+
 ### 6.1 Field lines
 
 `src/field_line_spectre.f90` traces field lines inside one volume as a
 
@@ -771,21 +771,21 @@ subroutine gram_cylindrical
         type(expr_t) :: rz(2), metric, dg, d2g, ev(3)
         integer :: i, j, k, l, c
         character(40) :: lab
-        call expect(fprov, 321, 'x = [rz(1)*cz, rz(1)*sz, rz(2)]')
-        call expect(fprov, 323, 'e(:, i) = [d(1, i)*cz, d(1, i)*sz, d(2, i)]')
-        call expect(fprov, 325, 'e(:, 3) = e(:, 3) + [-rz(1)*sz, rz(1)*cz, 0.0_dp]')
-        call expect(fprov, 326, 'metric = matmul(transpose(d), d)')
-        call expect(fprov, 327, 'metric(3, 3) = metric(3, 3) + rz(1)**2')
-        call expect(fprov, 331, 'dg(i, j, k) = dot_product(d2(:, i, k), d(:, j)) &')
-        call expect(fprov, 332, '+ dot_product(d(:, i), d2(:, j, k))')
-        call expect(fprov, 334, &
+        call expect(fprov, 373, 'x = [rz(1)*cz, rz(1)*sz, rz(2)]')
+        call expect(fprov, 375, 'e(:, i) = [d(1, i)*cz, d(1, i)*sz, d(2, i)]')
+        call expect(fprov, 377, 'e(:, 3) = e(:, 3) + [-rz(1)*sz, rz(1)*cz, 0.0_dp]')
+        call expect(fprov, 378, 'metric = matmul(transpose(d), d)')
+        call expect(fprov, 379, 'metric(3, 3) = metric(3, 3) + rz(1)**2')
+        call expect(fprov, 384, 'dg(i, j, k) = dot_product(d2(:, i, k), d(:, j)) &')
+        call expect(fprov, 385, '+ dot_product(d(:, i), d2(:, j, k))')
+        call expect(fprov, 388, &
             'd2g(i, j, k, l) = dot_product(d3(:, i, k, l), d(:, j)) &')
-        call expect(fprov, 335, '+ dot_product(d2(:, i, k), d2(:, j, l)) &')
-        call expect(fprov, 336, '+ dot_product(d2(:, i, l), d2(:, j, k)) &')
-        call expect(fprov, 337, '+ dot_product(d(:, i), d3(:, j, k, l))')
-        call expect(fprov, 341, 'dg(3, 3, k) = dg(3, 3, k) + 2.0_dp*rz(1)*d(1, k)')
-        call expect(fprov, 343, 'd2g(3, 3, k, l) = d2g(3, 3, k, l) + &')
-        call expect(fprov, 344, '2.0_dp*(d(1, k)*d(1, l) + rz(1)*d2(1, k, l))')
+        call expect(fprov, 389, '+ dot_product(d2(:, i, k), d2(:, j, l)) &')
+        call expect(fprov, 390, '+ dot_product(d2(:, i, l), d2(:, j, k)) &')
+        call expect(fprov, 391, '+ dot_product(d(:, i), d3(:, j, k, l))')
+        call expect(fprov, 395, 'dg(3, 3, k) = dg(3, 3, k) + 2.0_dp*rz(1)*d(1, k)')
+        call expect(fprov, 398, 'd2g(3, 3, k, l) = d2g(3, 3, k, l) + &')
+        call expect(fprov, 399, '2.0_dp*(d(1, k)*d(1, l) + rz(1)*d2(1, k, l))')
         q = [s('rho'), s('theta'), s('zeta')]
         rf = func('R', q); zf = func('Z', q)
         xc = [rf*cos(q(3)), rf*sin(q(3)), zf]
@@ -893,15 +893,15 @@ subroutine blend_potential
         type(expr_t) :: da(3), d2a(3, 3), tv
         integer :: i, j
         character(32) :: lab
-        call expect(fprov, 139, 'a = al + s(0)*(ar - al)')
-        call expect(fprov, 140, 'da = dl + s(0)*(dr - dl)')
-        call expect(fprov, 141, 'da(:, 1) = da(:, 1) + s(1)*(ar - al)')
-        call expect(fprov, 142, 'd2a = hl + s(0)*(hr - hl)')
-        call expect(fprov, 145, 'if (i == 1) d2a(:, i, j) = d2a(:, i, j) &')
-        call expect(fprov, 146, '+ s(1)*(dr(:, j) - dl(:, j))')
-        call expect(fprov, 147, 'if (j == 1) d2a(:, i, j) = d2a(:, i, j) &')
-        call expect(fprov, 148, '+ s(1)*(dr(:, i) - dl(:, i))')
-        call expect(fprov, 151, 'd2a(:, 1, 1) = d2a(:, 1, 1) + s(2)*(ar - al)')
+        call expect(fprov, 157, 'a = al + s(0)*(ar - al)')
+        call expect(fprov, 158, 'da = dl + s(0)*(dr - dl)')
+        call expect(fprov, 159, 'da(:, 1) = da(:, 1) + s(1)*(ar - al)')
+        call expect(fprov, 166, 'd2a = hl + s(0)*(hr - hl)')
+        call expect(fprov, 169, 'if (i == 1) d2a(:, i, j) = d2a(:, i, j) &')
+        call expect(fprov, 170, '+ s(1)*(dr(:, j) - dl(:, j))')
+        call expect(fprov, 171, 'if (j == 1) d2a(:, i, j) = d2a(:, i, j) &')
+        call expect(fprov, 172, '+ s(1)*(dr(:, i) - dl(:, i))')
+        call expect(fprov, 175, 'd2a(:, 1, 1) = d2a(:, 1, 1) + s(2)*(ar - al)')
         q = [s('rho'), s('theta'), s('zeta')]
         al = func('AL', q); arr = func('AR', q); w = func('W', [q(1)])
         a = al + w*(arr - al)
@@ -954,9 +954,10 @@ subroutine blend_leibniz
             1, 0, 0, 0, 1, 1, 0, 0, 1, 2, 1, 0, 1, 3, 3, 1], [4, 4])
         character(LN) :: o(4), wn(4)
         character(32) :: lab
-        call expect(fprov, 260, &
+        call expect(fprov, 298, &
             'integer, parameter :: binom(0:3, 0:3) = reshape([ &')
-        call expect(fprov, 261, '1, 0, 0, 0, 1, 1, 0, 0, 1, 2, 1, 0, 1, 3, 3, 1], [4, 4])')
+        call expect(fprov, 299, &
+                    '1, 0, 0, 0, 1, 1, 0, 0, 1, 2, 1, 0, 1, 3, 3, 1], [4, 4])')
         o = [character(LN) :: 'coeff(:, r)', 'real(binom(l, r), dp)', 'sw(l)', &
             '(cr(:, r - l) - cl(:, r - l))']
         wn = [character(LN) :: 'OLD', 'BIN', 'SW', 'DIFF']
@@ -968,7 +969,7 @@ subroutine blend_leibniz
             jl(r) = diff(jl(r - 1), rho); jr(r) = diff(jr(r - 1), rho)
             sw(r) = diff(sw(r - 1), rho)
         end do
-        t = src(fprov, 285, o, wn)
+        t = src(fprov, 333, o, wn)
         do r = 0, 3
             cf = jl(r)
             do l = 0, r
@@ -1021,33 +1022,33 @@ subroutine switch_chain
         w = [character(LN) :: 'S0', 'S1', 'S2', 'S3']
         rho = s('rho'); k = s('k'); width = s('width')
         ! Line 97 parsed with real(k, dp) -> (k).
-        t = src(fprov, 97, o, w)
-        phi = subs_many(src(fprov, 104, o, w), [s('t')], [t])
+        t = src(fprov, 109, o, w)
+        phi = subs_many(src(fprov, 116, o, w), [s('t')], [t])
         call ident('switch phi', phi - (-1/t + 1/(1 - t)))
         do br = 1, 2
             ! br=1: phi<0, small=exp(phi) (line 109 abs), s0 line 111.
             ! br=2: phi>=0, small=exp(-phi), s0 line 113.
             if (br == 1) then
                 small = exp(phi)
-                s0 = subs_many(src(fprov, 111, o, w), [s('small')], [small])
+                s0 = subs_many(src(fprov, 123, o, w), [s('small')], [small])
             else
                 small = exp(-phi)
-                s0 = subs_many(src(fprov, 113, o, w), [s('small')], [small])
+                s0 = subs_many(src(fprov, 125, o, w), [s('small')], [small])
             end if
-            sp = subs_many(src(fprov, 115, o, w), [s('small')], [small])
-            p1 = subs_many(src(fprov, 116, o, w), [s('t')], [t])
-            p2 = subs_many(src(fprov, 117, o, w), [s('t')], [t])
-            p3 = subs_many(src(fprov, 118, o, w), [s('t')], [t])
+            sp = subs_many(src(fprov, 127, o, w), [s('small')], [small])
+            p1 = subs_many(src(fprov, 128, o, w), [s('t')], [t])
+            p2 = subs_many(src(fprov, 129, o, w), [s('t')], [t])
+            p3 = subs_many(src(fprov, 130, o, w), [s('t')], [t])
             call ident('switch ph1 = dphi/dt', p1 - dt(phi))
             call ident('switch ph2 = d2phi/dt2', p2 - dt(dt(phi)))
             call ident('switch ph3 = d3phi/dt3', p3 - dt(dt(dt(phi))))
             call ident('switch s0 = logistic(phi)', s0 - 1/(1 + exp(-phi)))
             d(0) = s0
-            d(1) = subs_many(src(fprov, 119, o, w), &
+            d(1) = subs_many(src(fprov, 131, o, w), &
                 [s('sp'), s('ph1'), s('width')], [sp, p1, width])
-            d(2) = subs_many(src(fprov, 120, o, w), &
+            d(2) = subs_many(src(fprov, 132, o, w), &
                 [s('sp'), s('ph1'), s('ph2'), s('S0'), s('width')], [sp, p1, p2, s0, width])
-            d(3) = subs_many(src(fprov, 121, o, w), &
+            d(3) = subs_many(src(fprov, 133, o, w), &
                 [s('sp'), s('ph1'), s('ph2'), s('ph3'), s('S0'), s('width')], &
                 [sp, p1, p2, p3, s0, width])
             do m = 1, 3
@@ -1071,11 +1072,11 @@ subroutine gauge_projection
         type(expr_t) :: m, nn, dth, dze, wave(2), c, proj(2), th, ze, arg, chi
         type(expr_t) :: gc(2), gs(2), val(2), cc, cs
         m = s('m'); nn = s('n'); dth = s('dth'); dze = s('dze')
-        call expect(fprov, 72, 'wave = [real(m, dp), -real(n, dp)]')
-        call expect(fprov, 73, 'defect = maxval(abs(m*delta(2, :) + n*delta(1, :)))')
-        call expect(fprov, 80, &
+        call expect(fprov, 84, 'wave = [real(m, dp), -real(n, dp)]')
+        call expect(fprov, 85, 'defect = maxval(abs(m*delta(2, :) + n*delta(1, :)))')
+        call expect(fprov, 92, &
             'c = dot_product(wave, delta(:, r))/dot_product(wave, wave)')
-        call expect(fprov, 81, 'delta(:, r) = c*wave')
+        call expect(fprov, 93, 'delta(:, r) = c*wave')
         wave = [m, -nn]
         c = (wave(1)*dth + wave(2)*dze)/(wave(1)**2 + wave(2)**2)
         proj = [c*wave(1), c*wave(2)]
@@ -1258,14 +1259,14 @@ subroutine spectral_volume_chain
         type(expr_t) :: rho, th, ze, ow, sarg, g, q(3), u(3), gg, e
         integer :: i, j, slot(3, 3), nr
         character(32) :: lab
-        call expect(fprov, 171, &
+        call expect(fprov, 196, &
             'integer, parameter :: slot(3, 3) = reshape([1, 2, 3, 2, 4, 5, 3, 5, 6], [3, 3])')
-        call expect(fprov, 179, 'da(:, 1) = 2.0_dp*da(:, 1)')
-        call expect(fprov, 186, 'real(2**(merge(1, 0, i == 1) + merge(1, 0, j == 1)), dp)')
+        call expect(fprov, 204, 'da(:, 1) = 2.0_dp*da(:, 1)')
+     call expect(fprov, 212, 'real(2**(merge(1, 0, i == 1) + merge(1, 0, j == 1)), dp)')
         slot = reshape([1, 2, 3, 2, 4, 5, 3, 5, 6], [3, 3])
         rho = s('rho'); th = s('theta'); ze = s('zeta'); ow = s('owner')
         sarg = parse_rhs(ar, '2.0_dp*(q(1) - owner + 1) - 1.0_dp', ['q(1)'], ['rho '])
-        call expect(fprov, 174, '2.0_dp*(q(1) - owner + 1) - 1.0_dp, q(2), q(3), av)')
+  call expect(fprov, 199, '2.0_dp*(q(1) - owner + 1) - 1.0_dp, q(2), q(3), av, second)')
         q = [rho, th, ze]
         u = [s('u'), s('v'), s('w')]
         g = func('G', [sarg, th, ze])
@@ -1301,12 +1302,14 @@ subroutine geometry_fourier
         type(expr_t) :: k1(0:3), k2(0:3)
         integer :: r, t, z, i
         character(32) :: lab
-        call expect(fprov, 273, 'wave = [real(m, dp), -real(n, dp)]')
-        call expect(fprov, 275, 'c = [cos(arg), -sin(arg), -cos(arg), sin(arg)]')
-        call expect(fprov, 293, 'factor = wave(1)**t*wave(2)**z')
-        call expect(fprov, 294, 'jets(r, t, z, comp) = jets(r, t, z, comp) + factor* &')
-        call expect(fprov, 295, '(coeff(1, r)*c(mod(t + z, 4)) &')
-        call expect(fprov, 296, '- coeff(2, r)*c(mod(t + z + 1, 4)))')
+        call expect(fprov, 321, 'wave = [real(m, dp), -real(n, dp)]')
+        call expect(fprov, 323, 'c = [cos(arg), -sin(arg), -cos(arg), sin(arg)]')
+        call expect(fprov, 44, &
+                   'angular_factor(t, z, j) = real(spectre_field%data%im(j), dp)**t* &')
+        call expect(fprov, 341, 'factor = angular_factor(t, z, ii)')
+        call expect(fprov, 342, 'jets(r, t, z, comp) = jets(r, t, z, comp) + factor* &')
+        call expect(fprov, 343, '(coeff(1, r)*c(mod(t + z, 4)) &')
+        call expect(fprov, 344, '- coeff(2, r)*c(mod(t + z + 1, 4)))')
         rho = s('rho'); th = s('theta'); ze = s('zeta'); m = s('m'); nn = s('n')
         wave = [m, -nn]
         arg = wave(1)*th + wave(2)*ze
 
@@ -10,12 +10,12 @@ muts=(
  "batch_interpolate_3d.f90|2216|s/k2\*coeff_23/2*k2*coeff_23/"
  "batch_interpolate_3d.f90|1835|s/kk\*(kk - 1)/kk*(kk + 1)/"
  "batch_interpolate_3d.f90|1805|s/b1(k3, 3)/b0(k3, 3)/"
- "spectre_fo_gauss2.f90|120|s/2.0_dp\*s(0)/3.0_dp*s(0)/"
- "spectre_fo_gauss2.f90|117|s/-2.0_dp\/t/-3.0_dp\/t/"
- "spectre_fo_gauss2.f90|336|s/d2(:, j, k)/d2(:, j, l)/"
+ "spectre_fo_gauss2.f90|132|s/2.0_dp\*s(0)/3.0_dp*s(0)/"
+ "spectre_fo_gauss2.f90|129|s/-2.0_dp\/t/-3.0_dp\/t/"
+ "spectre_fo_gauss2.f90|390|s/d2(:, j, k)/d2(:, j, l)/"
  "spectre_basis.f90|43|s/2.0_dp\*cheby(ll - 1, 0)/3.0_dp*cheby(ll - 1, 0)/"
  "spectre_basis.f90|289|s/+ rmi\*rni/- rmi*rni/"
- "spectre_basis.f90|93|s/(m + 1)\*m\*(m - 1)/(m + 1)*m*(m + 1)/"
+ "spectre_basis.f90|94|s/(m + 1)\*m\*(m - 1)/(m + 1)*m*(m + 1)/"
 )
 status=0
 for m in "${muts[@]}"; do
 
@@ -14,7 +14,7 @@ cp "$fo_gauss2" "$here/build/src/spectre_fo_gauss2.f90"
 cp "$libneo/src/interpolate/batch_interpolate_3d.f90" "$here/build/src/"
 cp "$libneo/src/spectre/spectre_basis.f90" "$here/build/src/"
 ( cd "$here/build/src" && sha256sum -c --quiet - ) <<'SUMS'
-2257b247f459ce61f5ee0c5d9b131ee8541bfae1ad3cf00d4316dd575f141818  spectre_fo_gauss2.f90
+74018be12704da9032d6a4a33cca9155a92c2cf27cbdbc7d9a5aa3de8e8c8039  spectre_fo_gauss2.f90
 a249da9ca99fc217f621f498ad727d1c7dd3cc6ff02fd7ea079e6b43ab8adfc9  batch_interpolate_3d.f90
 21c3cefd7c6a518a9090e9a98fc2547a14fe7521c46479ff6e8e8a5f2d406d7d  spectre_basis.f90
 SUMS
 
@@ -14,11 +14,12 @@ more steps and an h/4 safety refinement, and the L4 obligations below are
 open. The test tree builds `spectre_fo_gauss2.f90` and the kernel as the
 test-only library `fo_gauss2_concept` so the proof chain stays executable.
 
-The six `generated/` leaves and the scalar generator in `gen/` are unchanged
-from that commit (only the regeneration scripts' paths were adapted). SIMPLE
-compiles the committed kernel without requiring a CAS. The registered regeneration test re-emits and compares all six
-leaves and runs the exact symbolic/readback checks (257/257 Hamiltonian and 6/6
-monitor identities). Thus the shipped expressions remain tied to L1/L2.
+The FortSym generators in `gen/` emit the Hamiltonian, monitor, factored
+Hessian, geometry contractions and potential accumulation in `generated/`.
+Verified: `gen/check_fo_generated.sh` checks byte regeneration, 271 exact
+Hamiltonian/readback identities, 153 factored-Hessian/readback identities and
+six monitor/product identities. The frozen reference is checked separately by
+its source hash and the executable field, derivative and map oracles.
 
 `results.json` and `proof-foundation.md` retain the original a27d1ec evidence;
 they are historical records, not a new run of the consolidated checkout. The