[pancetta]

The delta-form sweepers exist so that the implicit solve -- typically the expensive, often external part -- can work in, and return, a much lower precision while pySDC still converges to full precision. This PR writes down what the sweeper and the solver guarantee each other for that to hold, and makes the sweeper keep its side. It is the second step in moving the reduced-precision study (#784) into the library, after #785.

The contract

It is documented on Problem, replacing the note on the two optional delta-form methods, since a problem author looks there.

Routes, both existing:

• the stock solve_system with linear_implicit=True, for linear or affine operators;
• solve_system_delta(rhs, factor, base, f_base, t) for nonlinear ones. This is the contract for an external nonlinear solver.

The sweeper guarantees the solver:

• a correction equation, with a right-hand side that shrinks with the iteration and a zero initial guess;
• on the linear route, a right-hand side of unit size (new);
• base and f_base at the level's precision, read only, and factor a plain scalar;
• everything outside the solve kept at the level's precision, so each sweep is a step of iterative refinement around the solve.

The solver guarantees the sweeper:

• the correction, in any precision (new: the sweeper widens it);
• a relative accuracy η below what the method needs;
• relative tolerances only, and none below what its own precision can deliver;
• no boundary data or affine terms re-imposed on the correction.

The η values measured so far are given: SDC about 1e-4, an MLSDC fine level about 1e-6, an MLSDC coarse level about 1e-2.

Code

DeltaFormMixin._solve_correction's linear route goes through a new _solve_scaled, which:

• divides the right-hand side by its maximum and multiplies the result back. That is exact for a linear solve, and keeps a reduced-precision format clear of underflow: the correction it hands over shrinks below float16's smallest subnormal. It also turns an absolute solver tolerance into a relative one;
• removes the affine part after scaling. The stock solve adds it back unscaled, and the two only cancel at the same scale. The existing test_linear_implicit_handles_affine_operator caught the first version, which got this backwards;
• widens a result that comes back in another precision before scaling it, so the multiplication never happens at the solver's precision. This applies only to datatypes whose init names a dtype; PETSc and FEniCS types keep today's copy;
• returns a zero correction for a zero right-hand side without calling the solver.

At full precision the results are unchanged up to round-off: the scaling costs two roundings per solve. The node-parallel sweeper reuses _solve_correction, so it gets the same behaviour.

Decisions taken

• No scale argument on solve_system_delta. On the nonlinear route the scaled unknown enters f, so the sweeper can't scale for the solver. Instead, the contract says the solver scales internally if its format needs it, so existing implementations are unaffected.
• The required η is documented, not passed to the solver. The values are measured on the heat equation only; passing them as parameters can wait until they are known across problems and methods.
• solve_jacobian is not a third route, for now.

Tests

• test_half_precision_solver_reaches_full_precision: a heat problem whose solver rounds the right-hand side to float16, solves in single precision and returns float16. In delta form it reaches the double-precision floor; stock SDC with it stalls above 1e-6. With the scaling removed the test fails, at a floor of 1.2e-5.
• test_half_precision_result_is_widened: the stored corrections are float64.
• On a GPU, test_half_precision_solve_reaches_double_precision_in_delta_form (from Let the finite-difference problems solve at a precision of their own, and by FFT #785, CPU-only until now, where fp16 is emulated) also runs under the cupy marker. There the solve is cuFFT's genuine half-precision arithmetic, and delta-form SDC must still reach the double-precision floor while stock SDC with the same solve stalls. It passes on 4×T4 through etc/modal_gpu_tests.py. By hand at 256²: 4.9e-14 against 6.2e-14 in double, and the stock control stalls at 1.7e-1.

Local: black and ruff over pySDC; 1543 base tests across sweepers, transfers, problems, tutorials, test_core, test_reduced_precision and test_problem; and the delta-form MPI tests (test_delta_form_MPI, test_BaseTransferDelta_MPI) at every rank count they declare.

The docstrings of delta_form, delta_form_MPI and BaseTransferDelta now write the collocation residual as r, keeping ε for a format's precision, as the DeltaSDC README does.

🤖 Generated with Claude Code

[github-actions]

Coverage report

Click to see where and how coverage changed

File	Statements	Missing	Coverage	Coverage (new stmts)	Lines missing
pySDC/core
problem.py
pySDC/implementations/sweeper_classes
delta_form.py
delta_form_MPI.py
Project Total

This report was generated by python-coverage-comment-action