Struct SaeReconstructionRowProgram 

pub struct SaeReconstructionRowProgram {
    pub atoms: Vec<AtomRowBasisJet>,
    pub gate_value: Vec<f64>,
    pub logits: Vec<f64>,
    pub gate_scale: Vec<f64>,
    pub gate_shift: Vec<f64>,
    pub gate: RowGate,
    pub logit_slot: Vec<Option<usize>>,
    pub coord_slot: Vec<Vec<usize>>,
    pub n_primaries: usize,
}

One row of the SAE reconstruction as a jet program: the per-atom basis jets, the gate, the current gate-logit values, and the primary layout that maps (atom logit, atom latent axis) to a seeded tower variable slot.

Fields

atoms: Vec<AtomRowBasisJet>

Per-atom basis jets at the current row.

gate_value: Vec<f64>

Current gate activations ζ_k at the row (softmax/sigmoid values).

logits: Vec<f64>

Current gate logits ℓ_k at the row.

gate_scale: Vec<f64>

Per-atom multiplicative scale for independent logistic gates. This is the IBP stick-breaking prior π_k for IBP-MAP, 1 for active JumpReLU, and 0 for JumpReLU rows at/below the hard threshold. Unused for softmax.

gate_shift: Vec<f64>

Per-atom logistic shift (IBP offset / JumpReLU threshold); unused for softmax.

gate: RowGate

The gate nonlinearity.

logit_slot: Vec<Option<usize>>

Tower slot of atom k’s gate logit primary, or None if the gate logit is not a free primary for this atom (softmax K==1).

coord_slot: Vec<Vec<usize>>

Tower slot of atom k’s latent axis j primary (coord_slot[k][j]).

n_primaries: usize

Total number of seeded primaries (= K of the tower).

Implementations

impl SaeReconstructionRowProgram

pub fn reconstruction_column_packed<const K: usize>( &self, out_col: usize, ) -> Order2<K>

The reconstruction output column c as the PACKED order-2 jet Order2<K>: value .value(), gradient .g()[a] = ∂ẑ_c/∂p_a, Hessian .h()[a][b] = ∂²ẑ_c/∂p_a∂p_b.

This is the production path (#932): the arrow-Schur logdet consumer reads ONLY the order-≤2 channels of the reconstruction, so it builds the packed Order2<K> scalar — value/gradient/Hessian only — instead of the dense Tower4<K> (which materialises the entire K⁴ t3/t4 tensor every row only to discard it). For K up to 16 the dense tower’s tensor build is ~19× the instruction count of the order-2 channels alone; this collapses it to the channels actually read. The packed (v, g, H) is BIT-IDENTICAL to the order-≤2 channels of [Self::reconstruction_column_tower] (the Order2 newtype delegates to the same Tower2 arithmetic the dense tower’s order-≤2 channels use); the t3/t4 oracle pins the dense path.

pub fn reconstruction_all_columns_packed<const K: usize>( &self, ) -> Vec<Order2<K>>

All out_dim reconstruction columns as packed Order2<K> jets, with the per-row redundant sub-jets HOISTED out of the output-column loop (#932 perf). reconstruction_column_packed(c) rebuilds, for every output column c, both the per-atom softmax gate jet ζ_k (K exps + a recip

• a K×K Hessian — the dominant cost) AND each per-atom basis jet Φ_{k,b} — yet neither depends on c: the gate is a function of the logits only, and the basis jet is the local Taylor model of Φ_b in the coords, the decoder coefficient B_{b,c} being the only c-dependent factor. The consumer (fill_reconstruction_channels_from_program) calls it once per c, so the gate and basis jets are recomputed out_dim× redundantly.

This builds each atom’s gate jet ONCE (K total) and each atom’s basis jets ONCE (n_basis per atom), then assembles every column by the cheap reductions decoded_{k,c} = Σ_b Φ_{k,b}·B_{b,c} and ẑ_c = Σ_k ζ_k·decoded_{k,c}. The result is bit-identical to calling Self::reconstruction_column_packed per column (same Leibniz products in the same order) — only the redundant recomputation is removed — measured ~9× faster at K=8, out_dim=16 on the per-row hot path.

pub fn reconstruction_column<const K: usize>(&self, out_col: usize) -> Tower4<K>

The reconstruction output column as the full dense Tower4<K> carrying every value/gradient/Hessian/t3/t4 channel. This is the #932 oracle ground truth: the production Self::reconstruction_column_packed order-2 path is pinned against its order-≤2 channels, and the FD-witness tests use its t3/t4. Not on the per-row hot path.

pub fn beta_border_tower_packed<const K: usize>( &self, atom: usize, basis_col: usize, ) -> Order2<K>

The β border-channel local-variable sub-jet as the PACKED order-2 jet Order2<K>. The consumer reads only .value() (the beta channel) and .g()[a] (the beta_deriv / beta_l_deriv mixed channel — the reconstruction is linear in β so the Hessian-in-β vanishes and only value+gradient are needed). Built from the SAME packed gate / basis primitives as Self::reconstruction_column, so the dense t3/t4 tensor is never materialised on this per-row hot path (#932 Tower4→Order2 cutover).

pub fn beta_border_tower<const K: usize>( &self, atom: usize, basis_col: usize, ) -> Tower4<K>

The β border-channel sub-jet as the full dense Tower4<K> — the #932 oracle ground truth the packed Self::beta_border_tower_packed is pinned against. Not on the per-row hot path.

pub fn beta_border_towers_packed<const K: usize>( &self, channels: &[(usize, usize)], ) -> Vec<Order2<K>>

Packed β border-channel sub-jets for a batch of (atom, basis_col) channels, with the per-atom gate jets HOISTED and the softmax denominator SHARED across atoms (#932 perf): the gate jet ζ_k (the dominant K-exp / K×K-Hessian cost) is a function of the row’s logits only, not of basis_col, and every atom’s gate shares one softmax denominator / reciprocal. Self::all_gates builds all K gates once (K exps + 1 recip per row); each channel then just multiplies its atom’s cached gate by its basis jet. Each result is bit-identical to Self::beta_border_tower_packed for the same (atom, basis_col) (same gate.mul(basis) product), in the input order.

pub fn beta_border_order1_packed<const K: usize>( &self, channels: &[(usize, usize)], ) -> Vec<Order1<K>>

Packed β border-channel sub-jets for a batch of channels as the FIRST-order jet Order1<K> — value + gradient ONLY, no Hessian. The β-border consumer (fill_beta_border_channels_from_program) reads exactly .value() (the beta channel) and .g()[a] (the mixed beta_deriv / beta_l_deriv channel); the reconstruction is linear in β so the Hessian-in-β vanishes and the K×K Hessian that Self::beta_border_towers_packed’s Order2 builds is computed-and-discarded every call. This method drops that work: Order1’s value/gradient are BIT-IDENTICAL to Order2’s (the order-≤1 channels never read a Hessian), proven by the order1_* oracle, while the per-channel gate.mul(basis) skips the K² Hessian product.

Same hoisting as Self::beta_border_towers_packed: gate jets built once via Self::all_gates, each channel multiplies its atom’s gate by its basis jet.

pub fn out_dim(&self) -> usize

The number of reconstruction output columns.

impl SaeReconstructionRowProgram

Structural layout signature of a row program: the part that MUST be identical across rows for them to share one SIMD op graph (slot mapping, per-atom basis/latent/decoder shape, primary count). The per-row numeric data (phi/d_phi/d2_phi/decoder VALUES, logits) is what differs between lanes; the layout is what is shared.

pub fn reconstruction_all_columns_batch4<const K: usize>( rows: [&Self; 4], ) -> Option<[Vec<Order2<K>>; 4]>

All out_dim reconstruction columns for FOUR softmax-aligned rows at once, returned per row. Each row’s column vector is BIT-IDENTICAL to Self::reconstruction_all_columns_packed on that row (same hoisting, same Leibniz products in the same order — lane i mirrors the scalar row-i path). Returns None if the four rows are not softmax-aligned, so the caller can fall back to the scalar per-row path.

pub fn beta_border_order1_batch4<const K: usize>( rows: [&Self; 4], channels: &[(usize, usize)], ) -> Option<[Vec<Order1<K>>; 4]>

Packed β-border FIRST-order jets for a batch of (atom, basis_col) channels, for FOUR softmax-aligned rows at once, returned per row. Each row’s channel vector is BIT-IDENTICAL to Self::beta_border_order1_packed on that row. Returns None if the rows are not softmax-aligned.

Trait Implementations

impl Clone for SaeReconstructionRowProgram

fn clone(&self) -> SaeReconstructionRowProgram

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SaeReconstructionRowProgram

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.