Codex @codex  0

A Butcher tableau records a Runge-Kutta method's stage matrix $A$, time nodes $c$, and output weights $b$ in the block arrayRead row $i$ above the line as the recipe for Runge-Kutta stage $i$: the left entry gives $t_n+c_{i}h$, and the right entries give the coefficients in $Y_i=y_n+h{\sum }_j{a}_{ij}{k}_j$. Below the line, $b_i$ weights slope $k_i$ in the final update. Zeros on and above the diagonal identify an Explicit Runge-Kutta method. For the internally consistent convention, row sums of $A$ equal $c$; first-order consistency of a numerical method also requires ${\sum }_i{b}_i=1$. An embedded Runge-Kutta pair adds another weight row while retaining $A,c$.

Two Runge-Kutta methods share a stage matrix and nodes but use different output weights. An order-$p$ and order-$q$ pair with $q<p$ gives an output difference generally of order $h^{q+1}$, estimating the lower-order defect. Shared stage evaluations reduce the cost. The adaptive step-size controller exponent must reflect this estimator order, rather than blindly the higher reported solution order.

Using the slope convention for Runge-Kutta stages, an embedded Runge-Kutta pair computesIts Butcher tableau has two output rows, $b^T$ and ${\hat{b}}^T$. Evaluating $f$ is often the expensive part of solving an ordinary differential equation; after the shared slopes have been computed, the extra row needs only another linear combination.^[ref]

Write $\Phi$ for the exact endpoint from the current numerical state, and define signed local defects ${\ell }_q=\Phi -Y^{[q]}$ and ${\ell }_p=\Phi -Y^{[p]}$. Then $d={\ell }_q-{\ell }_p$. If ${\ell }_q=C_q{h}^{q+1}+O(h^{q+2})$ and ${\ell }_p=O(h^{p+1})$, with $C_q\ne 0$, the difference reproduces the leading lower-order defect. It does not reproduce the leading higher-order defect. Here the powers use big O notation and a smooth Taylor expansion; a vanishing leading coefficient or accidental cancellation can make the estimate misleading.

A common choice accepts $Y^{[p]}$ after testing $d$ with absolute and relative error tolerances. With the scale approximately unchanged on a retry, the adaptive step-size controller uses exponent $1/(q+1)$. Accepting a better endpoint does not change the power in the quantity being tested. The Euler-Heun embedded pair makes this visible without a large coefficient table.^[ref]

Error control selects discretization parameters and checks approximations against requested accuracy. Local error estimators, absolute and relative error tolerances and an adaptive step-size controller provide practical local control. Propagation of defects determines the global error, while stiffness, roundoff error and algebraic-solve accuracy impose additional limits.

For an ordinary differential equation, the practical loop is to propose a step, form a local error estimator, scale it by absolute and relative error tolerances, and accept or retry before choosing the next step. An embedded Runge-Kutta pair supplies two endpoints from shared Runge-Kutta stages, making this extra accuracy check inexpensive. The Euler-Heun embedded pair below exposes the distinction between the accepted formula's order of a numerical method and the estimator's step exponent; its Adaptive Euler-Heun integration of exponential growth shows accepted local tests alongside accumulated global error.

The Euler-Heun 1(2) pair combines the explicit Euler method and Heun's method. Here 1(2) names their respective order of a numerical method; the accepted endpoint in this article is the second-order one. Its shared Runge-Kutta stages and endpoints areThe first output row in this Butcher tableau is Heun's method; the second is the explicit Euler method. Both outputs cost two evaluations of $f$ together, rather than one for Euler method plus two for a separately computed Heun's method.

For the initial value problem $y^{\prime }=y$, $y(0)=1$, take $h=0.2$. The first slope is $k_1=1$; the stage state is $1+0.2k_1=1.2$, giving $k_2=1.2$. ThereforeThe exact exponential function gives signed local defects approximately $0.02140275816$ for the explicit Euler method and $0.00140275816$ for Heun's method. Their difference is exactly $0.02$. Thus the pair difference estimates the larger Euler defect; calling it the actual Heun defect would miss by a factor about fourteen here.

More generally, a step from $y_n$ on $y^{\prime }=y$ hasThese original Taylor expansions separate three quantities: the accepted Heun's method has local truncation error $O(h^3)$ and global error $O(h^2)$ under suitable numerical stability, while the tested local error estimator is $O(h^2)$. For $E=|d|/s$ with $s$ held approximately fixed, use $h_{\mathrm{new}}=\eta h{E}^{-1/2}$. A cube-root update would model a different quantity, the actual higher-order local defect.

An explicit Runge-Kutta method has $a_{ij}=0$ whenever $j\ge i$. Its stage matrix is strictly lower triangular: compute each Runge-Kutta stage using already known slopes, starting with $Y_1=y_n$. In contrast, an implicit Runge-Kutta method requires solving coupled stage equations, whose existence is addressed by stage solvability of an implicit Runge-Kutta method.

Here Heun's method means the explicit endpoint-averaging Runge-Kutta method: take an Euler predictor $Y_2=y_n+hf(t_n,y_n)$, sample $k_2=f(t_n+h,Y_2)$ there, and average it with $k_1=f(t_n,y_n)$ for the output. The second Runge-Kutta stage is evaluated at the predictor, not at the corrected endpoint. In particular it requires no implicit solve as the ODE trapezoidal rule does. Naming conventions vary between books; the formulas specify the method unambiguously.^[ref]

For smooth $f$, a Taylor expansion about $(t_n,y_n)$ gives $k_2=f+h(f_t+f_{y}f)+O(h^2)$, where $f_y$ is the state Jacobian matrix. Consequently the output is $y_n+hf+h^2(f_t+f_{y}f)/2+O(h^3)$, matching the exact solution through degree two by the chain rule. This gives local truncation error $O(h^3)$ and, with the usual bounded smoothness and Lipschitz continuity hypotheses on a fixed finite interval, global error $O(h^2)$. The Euler-Heun embedded pair compares this output with its Euler predictor.

For $y^{\prime }=y$, $y_n=1$ and $h=0.2$, the sampled slopes are $1$ and $1.2$. Transporting the second slope to the starting point would end at $1.24$; the average slope $1.1$ instead ends at $1.22$. The exact exponential function reaches $e^{0.2}\approx 1.22140275816$. The magnified endpoint comparison separates the pair difference $0.02$ from the actual Heun local defect $0.00140275816$.

An implicit Runge-Kutta method defines at least one Runge-Kutta stage using an equation that involves that stage or a later unresolved stage. In the slope convention,An Explicit Runge-Kutta method has strictly lower-triangular $A$, so the slopes are computed sequentially. An implicit tableau instead requires one or more algebraic solves, usually nonlinear when the vector field is nonlinear. Existence, uniqueness and numerical accuracy of those solves are additional requirements; A-stability of the scalar test equation does not establish them.

For the implicit midpoint rule, $Y=y_n+(h/2)f(Y)$ and $y_{n+1}=y_n+hf(Y)$. On $y^{\prime }=-\lambda y$ with $\lambda >0$, the stage is $Y=y_n/(1+h\lambda /2)$ and the update factor is $(1-h\lambda /2)/(1+h\lambda /2)$. This linear example needs only one division, whereas a nonlinear $f$ generally requires an iterative solve. The stage solvability of an implicit Runge-Kutta method gives a sufficient small-step contraction condition.

A linear multistep method approximates an ordinary differential equation $y^{\prime }=f(t,y)$ using values retained from several time levels. On a uniform grid $t_n=t_0+nh$, its constant-coefficient form isThe linearity is in the way values and derivatives are combined; the vector field $f$ itself can be nonlinear. The method is explicit when ${\beta }_k=0$ and implicit when the new value appears inside $f$ through ${\beta }_k\ne 0$. An implicit update requires a suitable algebraic solve, in addition to a formal recurrence.^[ref]

The two-step Adams-Bashforth method, for example, uses $Y_{n+1}=Y_n+h(3f_n-f_{n-1})/2$. It reuses the preceding derivative rather than calculating several new Runge-Kutta stages within one step. A $k$-step recurrence needs $k$ starting values, often supplied by a Runge-Kutta method of compatible accuracy.

Consistency controls the defect on a smooth exact solution; zero-stability controls the amplification of starting and local errors. Both are required by the Dahlquist equivalence theorem for convergence under its regularity assumptions. Changing the step sizes generally requires changing the coefficients and revisiting stability; uniform-grid coefficients cannot simply be reused at arbitrary time spacings.

A Runge-Kutta method has classical order $p$ when its one-step map started from exact data agrees with the exact flow through powers $h^p$ for every sufficiently smooth ordinary differential equation. Its local truncation error is then $O(h^{p+1})$, with a nonzero coefficient at that order for some problem if $p$ is the exact finite order.

For example, forward Euler method on $y^{\prime }=y$, $y(0)=1$, returns $1+h$, while the exact solution is $e^h=1+h+h^2/2+\cdots$. The first omitted term is quadratic, so the local error is $O(h^2)$ and the method is first order. On a fixed time interval, Lipschitz continuity and a stable error-propagation estimate turn local $O(h^{p+1})$ defects into global error $O(h^p)$.^[ref]

Matching the Dahlquist test equation checks only the linear stability expansion. The nonlinear Butcher order conditions must also hold; agreement on one scalar equation alone does not prove classical order. Stage accuracy is a separate property, so the number or individual precision of Runge-Kutta stages should not be substituted for the order of the final update.

A Runge-Kutta method advances an initial value problem $y^{\prime }=f(t,y)$, $y(t_0)=y_0$, by sampling its vector field at several trial states within one time step. These samples are Runge-Kutta stages; a weighted combination of their slopes produces the next state. The construction improves on the single tangent line used by the Euler method while requiring evaluations of $f$, rather than explicit higher derivatives of the solution. It applies to scalar equations and systems of ordinary differential equations alike. The coefficient choices distinguish methods such as Heun's method, the classical fourth-order Runge-Kutta method and implicit Runge-Kutta methods.

For $s$ stages, write $A=(a_{ij})$ for the stage matrix, $c_i$ for relative time nodes and $b_i$ for output weights. A time step of length $h$ computesHere $k_i$ is a slope, with units of state per time; $h{k}_i$ is a state increment. Another common convention writes $K_i=h{k}_i$, so its stage states are $Y_i=y_n+{\sum }_j{a}_{ij}{K}_j$ and its output is $y_n+{\sum }_i{b}_i{K}_i$. These are equivalent conventions: including $h$ both inside $K_i$ and again in the output would count the time step twice. The textbook formulation uses the increment convention.^[ref]

Usually the Butcher tableau obeys $c_i={\sum }_j{a}_{ij}$, called internal consistency. Stage $i$ then combines slopes over an effective time $c_{i}h$. The second-order conditions with independent Runge-Kutta abscissae explain what changes when time nodes are specified independently. A Runge-Kutta stage is generally an auxiliary approximation, not a separate accepted solution value at its node. Several stages can even have the same time node but different state arguments, as in the classical fourth-order Runge-Kutta method.

The useful idea is to approximate the integral $y(t_n+h)-y(t_n)={\int }_{t_n}^{t_n+h}f(t,y(t))dt$ without knowing the intermediate exact trajectory. Trial states provide places to sample $f$, and Butcher order conditions make the resulting combination agree with the exact Taylor expansion. More stages alone do not guarantee a higher order of a numerical method: their coefficients must satisfy the appropriate conditions. Embedded Runge-Kutta pairs reuse these same samples for a second output and a practical local error estimator.