Adaptive step-size — RK45, error control: Foundations

This page is the toolbox. Before you can read the parent note, you must own every symbol it throws at you. We build each one from nothing — plain words, then a picture, then why the topic needs it — in an order where each tool rests on the previous.

1. What a differential equation $y^{'} = f (t, y)$ even says

So $y^{'} = f (t, y)$ is a sentence: "At every point $(t, y)$ , here is the direction to head." It does not hand you the curve; it hands you an arrow at every point, and you must walk along the arrows to trace the curve.

Figure — Adaptive step-size — RK45, error control

Why the topic needs this. RK45 is a machine for walking along those arrows accurately. Every symbol later ( $k_{i}$ , $h$ , $ε$ ) is about taking one good step in the arrow field. If you don't see the field, nothing else lands.

Recall Check: what does

$f$ give you? $f (t, y)$ returns... ::: the slope (steepness) of the solution at the point $(t, y)$ — not the solution itself.

2. The step size $h$ — the length of one hop

Why "little"? The arrow field can bend. If you follow one straight arrow for a huge distance you drift off the true curve. A short hop stays close to the truth — but short hops are slow. This tug-of-war (accuracy vs speed) is the entire reason adaptive methods exist.

3. The slope samples $k_{i}$ — peeking before you leap

A crude method uses one slope (the arrow at the start) for the whole hop. A Runge–Kutta method is smarter: it peeks at several arrows inside the interval and blends them.

The Greek $Σ$ (sigma) just means add them all up: $\sum_{j < i} a_{ij} k_{j} = a_{i 1} k_{1} + a_{i 2} k_{2} + \dots$ up to the sample before $i$ .

Why the topic needs $k_{i}$ . These samples are the expensive part — every $k_{i}$ is a call to $f$ . The whole "free error estimate" trick works precisely because RK45 reuses the same $k_{i}$ for two different answers. You cannot appreciate "free" until you know $k_{i}$ is what costs money.

Recall Check: why is

$\sum_{j < i}$ and not $\sum_{j}$ ? Because each slope sample is built from the ones already computed — an explicit chain, so a sample never depends on itself.

4. Weighted sums $\sum b_{i} k_{i}$ — blending the peeks into one answer

Once you have all the peeked slopes $k_{1}, \dots, k_{s}$ (there are $s$ of them), you combine them into a single "effective slope" using weights $b_{i}$ , then take the hop:

$y_{n + 1} = y_{n} + h \sum_{i = 1}^{s} b_{i} k_{i}$

Why a weighted average and not just the first arrow? Averaging several arrows across the step cancels out the curving error much better — this is what makes RK "high order" instead of crude. The exact $b_{i}, c_{i}, a_{ij}$ come from Dormand–Prince (RK45 used by scipy solve_ivp).

5. The second weight row $b_{i}^{*}$ — two answers from ONE set of peeks

Here is the piece the whole topic pivots on, so we build it slowly.

You have the peeked slopes $k_{1}, \dots, k_{s}$ . To finish a step you blend them with a weight row $b_{i}$ . But nothing forces you to use only one weight row. The very same slopes $k_{i}$ can be blended a second time with a different set of weights, which we write $b_{i}^{*}$ (read "b-i-star" — a second, separate list of blend numbers).

Why the topic needs $b_{i}^{*}$ . Without a second weight row you would have to run a whole separate method (fresh, expensive $k_{i}$ ) just to estimate error. The star-row is the trick that makes RK45 cheap: same peeks, second blend, instant error ruler.

Recall Check: what is different between

$y^{(5)}$ and $y^{(4)}$ ? Only the weight row: $b_{i}$ vs $b_{i}^{*}$ — the slope samples $k_{i}$ are identical, which is why the estimate is nearly free.

6. Order $p$ — how fast the error shrinks

Reading $h^{p + 1}$ . RK45 controls the step off the order-4 answer $y^{(4)}$ , so $p = 4$ and the exponent is $p + 1 = 5$ . Halving $h$ then shrinks the error by $2^{5} = 32$ times. That steep power is why small steps buy so much accuracy, and why the update formula uses a fifth root.

This power law comes straight from Taylor Series Expansion: the first term the method fails to cancel is proportional to $h^{p + 1}$ . See Order of a Numerical Method and Local vs Global Truncation Error for where $p$ is pinned down.

7. The error estimate $ε$ — one number saying "how wrong"

Because $y^{(5)}$ (order 5) is far more accurate than $y^{(4)}$ (order 4), their gap is essentially the whole error of the weaker one — a free ruler, exactly as pictured in Section 5.

8. Tolerance $tol$ — the error budget you allow

Why both? If $y$ becomes huge, a tiny fixed $atol$ becomes an impossible demand; the $rtol ∣ y_{n} ∣$ term rescues you by scaling the budget. If $y$ passes through zero, $atol$ keeps the budget from collapsing to nothing. The accept/reject decision is simply the comparison $ε \leq tol$ .

Recall Check: why not use

$atol$ alone? Because when $∣ y ∣$ grows large a fixed absolute floor is impossibly strict — the relative term lets the budget scale with the solution.

9. Putting the symbols together — the vocabulary the topic assumes

Symbol	Plain meaning	Picture
$y^{'} = f (t, y)$	slope-recipe at every point	arrow field
$h$	length of one hop in $t$	horizontal gap
$t_{n}, y_{n}$	where we currently stand	a dot on the curve
$k_{i}$	$i$ -th peeked slope	small arrows inside the step
$b_{i}$	higher-order (order 5) blend weights	recipe for the accurate average
$b_{i}^{*}$	lower-order (order 4) blend weights, same $k_{i}$	recipe for the second average
$y^{(5)}, y^{(4)}$	the two answers from the two rows	two landing dots
$p$	order (error shrink rate)	steepness of the error curve
$ε$	estimated step error	gap between the two answers
$tol$	error budget	the line you must stay under

Everything in the parent's boxed formula $h_{new} = h (tol / ε)^{1/ (p + 1)}$ is now a symbol you've built: a hop length, an error budget, an estimate (from two weight rows), and an order.

Prerequisite map

Equipment checklist

I can state what

f (t, y)

returns

The slope of the solution at the point

(t, y)

— an arrow, not the curve.

I can say what

h

is and the trade-off in choosing it

The length of one hop in

t

; small

h

= accurate but slow, large

h

= fast but risks flying off bends.

I know what

t_{n}

and

y_{n}

mean

The time we currently stand at and the solution's height there (

n

counts steps).

I can read

\sum_{j < i} a_{ij} k_{j}

"Add up the earlier slope samples, each scaled by

a_{ij}

" — a chain where each peek uses previous peeks.

I know what a slope sample

k_{i}

is and why it's expensive

An evaluation of

f

inside the step; each one is a costly function call, so RK45 reuses them.

I can explain the difference between

b_{i}

and

b_{i}^{*}

Two weight rows over the SAME

k_{i}

b_{i}

gives the order-5 answer,

b_{i}^{*}

the order-4 answer.

I can say what

y^{(5)}

and

y^{(4)}

are

The two hops built from the two weight rows; the superscripts label the order, not powers.

I can explain why two answers give a free error estimate

The accurate

y^{(5)}

stands in for the truth, so

y^{(5)} - y^{(4)}

is essentially the error of

y^{(4)}

, and the costly

k_{i}

are reused.

I can explain what "order

p

" measures

How fast the local error shrinks with

h

: error

\approx C h^{p + 1}

I know why the local exponent is

p + 1

, not

p

Local (per-step) error scales as

h^{p + 1}

; the global error scales as

h^{p}

I can state what

ε

estimates and where it comes from

The size of the step's error, from

∥ y^{(5)} - y^{(4)} ∥ = ∥ h \sum_{i} (b_{i} - b_{i}^{*}) k_{i} ∥

I can write and read

tol = atol + rtol ∣ y_{n} ∣

A per-step error budget mixing a fixed floor and a solution-scaled part.

I can decide accept vs reject

Accept the hop if

ε \leq tol

, else reject and retry with smaller

h

Connections

4.8.25 Adaptive step-size — RK45, error control (Hinglish) — the parent topic these foundations feed.
Runge–Kutta Methods (RK4) — where the stages $k_{i}$ and weights $b_{i}$ come from.
Taylor Series Expansion — the origin of the $h^{p + 1}$ error law.
Order of a Numerical Method — pins down the $p$ in the exponent.
Local vs Global Truncation Error — why per-step error is $h^{p + 1}$ .
Dormand–Prince (RK45 used by scipy solve_ivp) — the actual $a_{ij}, b_{i}, c_{i}$ table.
Stiff ODEs and Stability — when even adaptive explicit steps struggle.