PyAutoLens: PositionsLH penalty is silently zero when positions contain inf rows (always, when chained from a result)

[samlange04]

Package: PyAutoLens (autolens), current main (a1b698063). Platform: macOS, Python 3.13 (not platform specific).

What happens

The multiple-image position penalty chained from a previous result does nothing when the positions contain (inf, inf) rows, and the point solver's output always does. The SLaM pipelines in autolens_workspace chain it with

positions_likelihood = source_lp_result.positions_likelihood_from(factor=3.0, minimum_threshold=0.2)

for the source_pix and mass_total stages. positions_likelihood_from solves the previous model for the images of its source centre. The solver returns a fixed-length grid padded with (inf, inf): for a real HST lens (SLACS J0008-0004, F814W) that was 2 images plus 18 inf rows.

In that fit, source_pix[1] walked to a demagnified solution with theta_E = 0.37" against 1.47" from the parametric source stage. Its positions.info showed the violation plainly (threshold 0.2", max source-plane separation of the maximum-likelihood model 2.38") but the fit kept it, and every later stage inherited it.

Cause

PositionsLH.log_likelihood_penalty_from (autolens/analysis/positions.py) takes xp.max over furthest_separations_of_plane_positions. An inf position traces to nan, so the max is nan, nan > threshold is False in both the numpy branch and the jax.lax.cond branch, and the penalty is 0 for every model.

output_positions_info goes through max_separation_of_plane_positions, which uses a nan-safe max, so the info file reports the true separation and hides that the likelihood saw nothing. positions_threshold_from is also nan-safe (np.nanmax), so the threshold is correct; only the penalty is affected.

Reproduced with the real positions and the fitted mass: the max is nan at theta_E 0.369" and at 1.2" alike, while the finite-only max is 2.384" and 0.857".

Any user chaining the penalty from a result, which is every SLaM pipeline with a pixelized source, is exposed.

Proposed fix

Drop non-finite rows in PositionsLH.__init__ (in numpy, at construction, so the JAX path sees a clean static grid) and raise PositionsException when fewer than two finite positions remain, extending the existing check for exactly one position.

Two alternatives I did not take, which may be worth discussing: positions_likelihood_from could strip the padding before building the object, and the penalty could use a nan-safe max. A nan-safe max would also hide a real position that traces to nan, so filtering at construction seemed the narrower change.

Branch: https://github.com/samlange04/PyAutoLens/tree/fix/positions-lh-non-finite, with a regression test (images at +/-1" padded with inf rows; the penalty is 0 at theta_E = 1" and fires at 0.3", red on main).

[samlange04]

PR: PyAutoLabs/PyAutoLens#765

[Jammy2211]

Thanks @samlange04, this was an excellent report: precise root cause (inf → nan → nan > threshold is False on both the numpy and lax.cond paths), a real-lens reproducer, and a clear explanation of why the nan-safe positions.info masked it. We confirmed it on the pre-fix code, where padded solver output from a JAX-backed analysis gave a zero penalty even for a wildly wrong Einstein radius. Your PR #765 is now merged into PyAutoLens main with your regression tests, and filtering at construction was the right call over a nan-safe max for exactly the reason you gave. It will ship in the next release; until then, anyone running SLaM source_pix/mass_total stages on a JAX-backed analysis should re-check fits whose positions.info reports a max separation far above the threshold. Thanks again!