Affected Repositories

• PyAutoArray (primary)

Branch Survey

worktree_check_conflict reuse-cholesky-factor PyAutoArray → no conflict.

Suggested branch: feature/reuse-cholesky-factor

Implementation Steps

1. autoarray/inversion/inversion/abstract.py: add @cached_property _curvature_reg_matrix_cho_factor. It returns scipy.linalg.cho_factor(curvature_reg_matrix, lower=True, check_finite=False) when self._xp is np, not settings.use_positive_only_solver and settings.log_det_method == "cholesky". It returns None under any other gate, on LinAlgError (scipy's is numpy's class), or when the factor's diagonal is non-finite. It never overwrites curvature_reg_matrix.
2. reconstruction: in the positive-negative branch, if the factor is present, return scipy.linalg.cho_solve(factor, data_vector, check_finite=False). Otherwise call the unchanged inversion_util.reconstruction_positive_negative_from.
3. log_det_curvature_reg_matrix_term: after the positive-only fast path, if all_linear_obj_have_regularization and the factor is present, return 2.0 * np.sum(np.log(np.diag(factor[0]))). Otherwise take the unchanged _log_det_symmetric_from(curvature_reg_matrix_reduced). The log det reads the factor property directly, so it still does not evaluate the reconstruction.
4. Tests (new test_autoarray/inversion/inversion/test_positive_negative_shared_cholesky.py): imaging and interferometer fixture inversions, where the reconstruction equals np.linalg.solve to rtol 1e-10 and the log det equals the dense Cholesky to 1e-9, and the factor is computed once and shared; non-PD (indefinite, nonsingular) F + H where the reconstruction equals the LU solution and the log det raises LinAlgError (test mode off) / returns 0.0 (test mode on); slogdet unchanged and factor None; positive-only unaffected and factor None; a partially regularized system where the solve uses the factor and the log det takes the dense reduced route.
5. Witness: Aris bd.py breakdown at 1,405 (--mesh step2) and 2,947 (--mesh sp) vertices, single thread, before (canonical main) and after (worktree). Record the full-call median and the solve+log-det share, logL agreement (1e-9) and the reconstruction max relative difference. Pass: ≥15% at 1,405 and ≥35% at 2,947.

Key Files

• autoarray/inversion/inversion/abstract.py: reconstruction, log_det_curvature_reg_matrix_term, new factor property
• autoarray/inversion/inversion/inversion_util.py: reconstruction_positive_negative_from (unchanged; fallback)

Reuse one Cholesky factor of F+H for the reconstruction solve and the log det (numpy, non-positive-only path)

Type: feature
Target: PyAutoArray
Repos:

• PyAutoArray
  Difficulty: small
  Autonomy: safe
  Priority: high
  Status: formalised
  Consequence: glance
  Witness: on the Aris 125x125 interferometer setup (Delaunay + AdaptSplit, use_positive_only_solver=False, numba route) one likelihood call drops by >=15% at 1,405 vertices and >=35% at 2,947 vertices, with reconstruction unchanged to 1e-10 relative and log_det_curvature_reg_matrix_term unchanged to 1e-9
  Review-minutes: 3
  Unattended: ready

Profiled 2026-10-15 (session 3e3dea38, PyAutoArray main 17caf22) on Aris's SPT2319-55 data with
use_positive_only_solver=False: the numpy path factorizes the same SPD matrix F + H twice per
likelihood call — np.linalg.solve (LU) in inversion_util.reconstruction_positive_negative_from
(called from AbstractInversion.reconstruction, abstract.py ~760) and np.linalg.cholesky in
_log_det_symmetric_from for log_det_curvature_reg_matrix_term. Together 31% of the call at 1,405
vertices (100 + 70 ms of 0.63 s) and 72% at 2,947 vertices (976 + 741 ms of 2.0–2.4 s). The
positive-only path already reuses its factor (log_det_from_passive_cholesky_from); the non-positive
path does not.

Do: when use_positive_only_solver=False on the numpy backend, compute one scipy.linalg.cho_factor
of F + H, solve with cho_solve, and take the log det as 2 * sum(log(diag)) of the same factor
(keep the existing LinAlgError test-mode guard and the slogdet opt-in; JAX path unchanged).
Measured on the saved matrices: 65 ms vs 113+81 ms (1,405) and 612 ms vs 948+654 ms (2,947);
solution relative change 7e-14 / 2e-11; log det identical; non-PD still raises. Optionally fold in
an in-place F + H add to drop one S×S copy (10–30 ms). Do NOT use float32 (0.027 nats log-det
error at 2,947; cond(F+H) up to 7e12). Add a test pinning solve + log det against the two-factorization
values. Evidence: session 3e3dea38 scratchpad report_aris_speedups.md + aris_research/la.py
(temporary); campaign PyAutoLabs/PyAutoPulse#62.