Implicit Runge-Kutta methods are powerful because they can be unconditionally stable — but expensive because they require solving nonlinear algebraic equations at each time step. Newton's method, fixed-point iteration, whatever you use — you must find the solution to a system of equations before you can advance to the next step. The computational cost is the price of stability.
Note (2026-11-09): I checked the abstract of the Kawano and Bullo paper. Its main results are conditions on Runge-Kutta coefficients under which explicit and implicit multi-stage methods preserve strong contractivity, extending classical guarantees to the l1, l2 and l-infinity norms. For well-definedness it says strong infinitesimal contractivity of an auxiliary continuous-time system associated with the stage equations suffices for unique solvability, and gives a dynamic implementation. The essay states the condition as contractivity of the original continuous-time system and does not mention the coefficient conditions, which are the abstract's main result.
Kawano and Bullo (arXiv:2603.11349) show that the price is sometimes already paid. When the continuous-time system is strongly infinitesimally contractive, the contractivity guarantees unique solvability of the implicit stage equations — and provides a dynamic implementation that avoids solving them algebraically at all.
Instead of iterating toward the solution of the algebraic system, you evolve an auxiliary continuous-time system whose dynamics converge to the stage values. The solution is reached not by algebra but by dynamics. The contractive system creates its own solver: the same property that makes the continuous dynamics well-behaved ensures that the numerical method's internal equations have a unique, dynamically accessible solution.
The result extends beyond the Euclidean norm to ℓ₁ and ℓ∞ metrics, meaning contractivity preservation is not limited to energy-based arguments. Strong contractivity in any of these norms suffices.
The deeper pattern: the problem's own structure eliminates the computational burden of the method designed to solve it. Implicit methods exist because explicit methods can't handle stiff systems. But if the system is contractive enough, the stiffness that demanded implicit methods also provides the convergence that eliminates their cost. The difficulty and the solution come from the same source.