Unverified 2026

Core-Response Gram Preconditioner

Implementation & benchmark of arXiv:2608.14162 — TOGEARI: Interaction-Space Preconditioning for Condensed Finite-Element Systems with IPC Contact

Usefulness6/10
Difficulty6/10
Novelty4/10

Source paper: TOGEARI: Interaction-Space Preconditioning for Condensed Finite-Element Systems with IPC Contact arXiv:2608.14162 ⓘ · analyzed Sep 1, 2026

AI-generated research hypothesis, automatically tested. Not peer-reviewed.

Idea description

Replace a purely diagonal or block-diagonal optimizer preconditioner with a truncated Woodbury correction selected in interaction coordinates. Per-example gradient combinations are ranked by their response through the base inverse preconditioner, so the retained directions are those most affected by curvature after normalization rather than merely those with the largest raw gradient norm.

Formulas

$$A=M+U^{T}U+N,\qquad M=K_{0}+K_{\mathrm{vol}},\qquad K_{\mathrm{vol}}=B^{T}D^{-1}B,\qquad U=J.$$
$$G_M=UM^{-1}U^{T}.$$
$$G_M=V\Lambda V^T,\quad \lambda_1\ge\cdots\ge\lambda_m\ge0,\qquad \widetilde H_r=M+U^TV_rV_r^TU.$$
$$\widetilde H_r^{-1}=M^{-1}-M^{-1}U^TV_r(I_r+\Lambda_r)^{-1}V_r^TUM^{-1},\qquad \max_{z\perp V_r,\ \|z\|=1}z^TG_Mz=\lambda_{r+1}.$$

Mathematical statement

The paper decomposes the Newton matrix as A=M+U^TU+N, where M is a reusable positive-definite core, U is an interaction-factor matrix, and N contains terms excluded from the reference pair. Its central interaction-response operator is G_M=UM^{-1}U^T. Let G_M=V Lambda V^T, with orthonormal eigenvectors V=[v_1,...,v_m] and eigenvalues lambda_1>=...>=lambda_m>=0. Retain V_r=[v_1,...,v_r] and define U_r=V_r^TU, giving the rank-r approximation M+U^TV_rV_r^TU. Since V_r^TUM^{-1}U^TV_r=Lambda_r, the Woodbury inverse is (M+U^TV_rV_r^TU)^{-1}=M^{-1}-M^{-1}U^TV_r(I_r+Lambda_r)^{-1}V_r^TUM^{-1}. Truncating the largest eigenvalues minimizes the largest omitted core-normalized response, because max_{z perpendicular to V_r, ||z||=1} z^TG_Mz=lambda_{r+1}. In the neural adaptation, M is a positive diagonal or block-diagonal curvature estimate, U contains per-example gradients as rows, and G_M measures interaction strength after applying M^{-1}.

Implementation notes

(1) Integration point: implement this as an optimizer preconditioner immediately before the parameter update. Flatten the trainable parameters into p in R^d. Let g=gradient_p of the minibatch loss. Use Adam's bias-corrected diagonal second moment, a diagonal Gauss-Newton estimate, or a block-diagonal K-FAC estimate as the positive-definite core M; add damping epsilon I so the inverse exists. Construct U in R^(b by d) from per-example gradients u_i=gradient_p loss_i, optionally scaled by 1/sqrt(b), with one row per example. (2) Pseudocode: M_inv = inverse_core(M); Y = U @ M_inv; G = Y @ U.T; compute the top-r eigendecomposition G V_r = V_r Lambda_r using symmetric Lanczos; C = M_inv @ U.T @ V_r; q = V_r.T @ U @ M_inv @ g; precond_g = M_inv @ g - C @ (q / (1 + Lambda_r)); update p <- p - eta * precond_g, with optional decoupled weight decay. The Woodbury equation supplies the exact correction. (3) Compute from the paper's mathematics: G, its leading eigenvectors and eigenvalues, and the low-rank inverse correction. Estimate empirically: M, damping, rank r, and the refresh interval. Refresh the eigenspace every 10 to 100 steps and reuse it between refreshes. To reduce memory, apply M_inv layerwise and store only r preconditioned interaction vectors rather than a dense d by d matrix. For large batches, form U from a random microbatch or use a small reservoir of per-example gradients. (4) First cheap experiment: train a two-layer MLP and a small ViT on MNIST and CIFAR-10 using SGD, AdamW, diagonal natural-gradient/K-FAC, and this method at ranks r in {1,2,4,8}. Match wall-clock time and gradient FLOPs, and measure loss after a fixed update budget, steps to target accuracy, final accuracy, and sensitivity to learning rate. Compare response-Gram selection against raw-gradient PCA and random interaction directions. Success means faster loss descent or fewer steps to target accuracy at matched compute; failure means eigendecomposition and per-example-gradient overhead increases without improving optimization.

Verification

This idea has not been verified yet.

Verification happens in two stages: Stage 1 — a mechanism check on a toy system confirms the claimed mathematical phenomenon reproduces; Stage 2 — a benchmark implements the idea on a real (small) neural network task and compares it against a tuned baseline over 8 paired seeds with a permutation test.

Artifacts

Artifacts unavailable.