Struct SparseBlockKroneckerPenaltyOp 

pub struct SparseBlockKroneckerPenaltyOp {
    pub p: usize,
    pub dim_a: usize,
    pub k: usize,
    pub blocks: Vec<SparseGBlock>,
}

Block-sparse Kronecker penalty P = A ⊗ I_p where the left factor A (dimension dim_a × dim_a in μ-space) is stored only on its non-empty co-occurring atom-pair blocks rather than as a dense (dim_a × dim_a) matrix.

This is the sparse-atom (K = 100K) replacement for wrapping the dense data-fit Gauss-Newton Gram G (m_total × m_total) in a KroneckerPenaltyOp: with per-row active sets of size k_active ≪ K, only the (atom, atom') pairs that co-occur in some row contribute a non-zero (m_i × m_j) block, so the storage and every matvec/diagonal pass cost O(Σ_pairs m_i m_j · p) instead of O((m_total · p)²).

The β index of left-factor coordinate μ and output channel oc is μ · p + oc (the same μ-major / oc-minor layout the dense KroneckerPenaltyOp { factor_b: I_p } uses), so this op is a drop-in structured replacement: with the full dense pair set it reproduces the dense operator exactly.

Fields

p: usize

Right-factor identity dimension p (number of decoder output channels).

dim_a: usize

Left-factor dimension dim_a in μ-space (= m_total).

k: usize

Full β dimension K = dim_a · p.

blocks: Vec<SparseGBlock>

Non-empty (atom_i, atom_j) coupling blocks of A.

Trait Implementations

impl BetaPenaltyOp for SparseBlockKroneckerPenaltyOp

fn dim(&self) -> usize

Full dimension K of the β vector.

fn matvec(&self, x: &[f64], y: &mut [f64])

y += P x — penalty Hessian-vector product (length K).

fn gradient(&self, beta: &[f64], out: &mut [f64])

Penalty gradient: out += P β.

fn diagonal(&self, diag: &mut [f64])

diag += diag(P) — diagonal entries used by Jacobi preconditioner.

fn block( &self, id: BetaBlockId, offsets: &[Range<usize>], out: &mut Array2<f64>, )

Add the b×b dense penalty sub-block for block id into out (row-major, block size b = offsets[id.0].len()). Used by the block-Jacobi Schur preconditioner (#287).

fn to_dense(&self) -> Array2<f64>

Materialize the full K×K dense penalty matrix (needed by Direct / SqrtBA modes that form the Schur complement explicitly).

fn row_abs_sums(&self) -> Array1<f64>

Per-row absolute-value sums out[r] = Σ_c |P[r,c]|, the row contribution to the operator’s ∞-norm. The default folds to_dense(), which costs an O(K²) materialization; structured operators override this to fold their compact factors directly so the backward-error certificate’s arrow_operator_infinity_norm never builds a dense K×K matrix on the SAE LLM-border critical path (#1017). Overrides MUST agree bit-for-bit with the to_dense() row sums (verified by the cross-check tests).

fn fingerprint(&self, hasher: &mut Fingerprinter)

Mix the operator’s defining state into hasher for cache-validity fingerprinting. Must change whenever matvec / to_dense would change, so the factorization / evidence cache (cache_matches_system) is invalidated when the β-block content changes. Implementations hash their own compact defining data (e.g. Kronecker factors, block matrices) rather than the full K×K dense form, which would defeat the structured operator’s storage savings.