Systems of ODEs — RK4 for systems: Question bank

Before we start, one reminder of the notation used throughout, so nothing here is unexplained:

$y = (y_{1}, \dots, y_{n})^{T}$ is the stacked column of all unknowns at a moment in time.
$f (t, y)$ returns the stacked column of slopes $(y_{1}^{'}, \dots, y_{n}^{'})$ .
$k_{1}, k_{2}, k_{3}, k_{4}$ are four slope-vectors (each length $n$ ) sampled across one step of width $h$ .
$h$ is the step size (how far in $t$ we jump each step).

True or false — justify

Every item: decide true/false, then give the reason. The reason is the answer.

RK4 for a system is a genuinely new algorithm, unrelated to scalar RK4.

False — it is the identical recipe with every scalar symbol replaced by its vector version; the weights

1, 2, 2, 1

over

6

and the stage structure are unchanged.

You can solve each equation of a coupled system with its own independent scalar RK4 run.

False — because

f_{i}

depends on all components, so any stage after

k_{1}

needs the advanced state of the other unknowns, which an independent run has not computed yet.

If the two equations happen to be uncoupled (each

f_{i}

depends only on its own

y_{i}

), then running scalar RK4 separately gives exactly the same answer as the vector method.

True — with no coupling the advanced state of one component never enters another's slope, so the stages decouple and independent scalar runs coincide with the system method.

RK4 for systems changes the weights to

1, 2, 2, 1

over

8

because there are two equations.

False — the weights are a property of the time-quadrature (Simpson-like sampling over one step), not of how many unknowns there are; they stay

1, 2, 2, 1

over

6

for any

n

Each

k_{i}

is a single number that gets reused for all components.

False — each

k_{i}

is a length- $n$ vector; component

j

k_{i}

is the estimated slope of

y_{j}

at that stage.

The global truncation error of RK4 for a system is

O (h^{4})

, the same order as for a scalar.

True — the Taylor-matching that gave order 4 used only algebra of

f

h

and addition, which behaves identically on vectors, so the order is preserved component-by-component.

If you halve

h

, you should expect the global error to drop by roughly a factor of

16

True — global error is

O (h^{4})

and

(1/2)^{4} = 1/16

, so halving the step cuts error about sixteenfold (until round-off dominates).

A 2nd-order ODE cannot be handled by RK4-for-systems; you need a special second-order solver.

False — you rename derivatives (

u_{1} = y, u_{2} = y^{'}

) to convert it into a first-order system, which RK4-for-systems then solves directly.

The intermediate state passed into

k_{2}

y_{n} + \frac{h}{2} k_{1}

evaluated at time

t_{n} + \frac{h}{2}

True —

k_{2}

probes the slope at the predicted midpoint, so both the time argument and the state argument advance by half a step using

k_{1}

k_{4}

uses a full step

h

in the state, not a half step.

True —

k_{4} = f (t_{n} + h, y_{n} + h k_{3})

samples the slope at the end of the interval, so it advances by the whole

h

Spot the error

Each item shows a plausible-sounding statement or step. Say what is wrong and why.

"I computed all of

k_{1}, k_{2}, k_{3}, k_{4}

for

y_{1}

first, then repeated for

y_{2}

The error is losing stage synchronization:

k_{2}

y_{1}

needs

y_{2}

's advanced state, which doesn't exist yet if

y_{2}

hasn't been stepped alongside; compute the whole vector

k_{1}

first, then the whole

k_{2}

, and so on.

"For

k_{3}

I used the state

y_{n} + \frac{h}{2} k_{1}

Wrong slope fed in —

k_{3}

must use the refined midpoint state

y_{n} + \frac{h}{2} k_{2}

; reusing

k_{1}

there collapses

k_{3}

into

k_{2}

and destroys the fourth-order accuracy.

"To reduce

y^{''} = g (t, y, y^{'})

I set

u_{1} = y^{'}

and

u_{2} = y

The labels are backwards for readability but the real trap is consistency: whatever you name them, you need

u_{1}^{'} = u_{2}

(or the matching pair) — if you write

u_{1}^{'} = g

while

u_{1} = y^{'}

, you have

y^{''} = g

paired with the wrong second equation and the system no longer encodes the original ODE.

"My final update was

y_{n + 1} = y_{n} + \frac{h}{6} (k_{1} + k_{2} + k_{3} + k_{4})

The middle two slopes are missing their weight of

2

; the correct combination is

\frac{h}{6} (k_{1} + 2 k_{2} + 2 k_{3} + k_{4})

, which mimics Simpson's

1, 4, 1

pattern (the two midpoint samples together give the

4

"I dropped the

\frac{h}{6}

factor because

h

was small anyway."

The

\frac{h}{6}

is not optional smallness — it is the step's length scaling; without it you add a raw slope with no units of time, giving a wildly wrong (and

h

-independent) jump.

"In

k_{2}

I advanced the time to

t_{n} + \frac{h}{2}

but kept the state at

y_{n}

You must advance both the time and the state; using the old state

y_{n}

with a new time makes

k_{2}

an inconsistent slope and breaks the midpoint prediction the method relies on.

"Since

k_{1}

already gives a good slope, I skipped

k_{2}, k_{3}, k_{4}

to save time."

Using

k_{1}

alone is just Euler's method (see Euler's method for systems), which is only order-1 accurate globally; the whole point of the extra three samples is to reach order 4.

Why questions

Answer with the underlying reason, not just a restatement.

Why does replacing scalars by vectors leave the RK4 weights unchanged?

Because the order-4 derivation only matched Taylor terms using addition, scalar multiplication by

h

, and function evaluation — all of which act identically on each vector component, so no weight ever needed re-tuning.

Why does RK4 sample the slope twice at the midpoint (giving

k_{2}

and

k_{3}

It mimics Simpson's rule, whose accuracy comes from weighting the midpoint heavily; two successive midpoint estimates (

k_{3}

using the improved

k_{2}

) let the method cancel more Taylor error than a single midpoint could.

Why must every component advance together at each stage?

Because the components are coupled —

f_{i}

reads the other unknowns — so a stage's slope is only meaningful if it sees a consistent snapshot where all components have moved to the same intermediate time. (See Simpson's Rule for the quadrature this imitates.)

Why is reducing a high-order ODE to a first-order system worthwhile at all?

It lets a single algorithm (RK4-for-systems) solve ODEs of any order, so you never need a separate integrator per order; naming the derivatives as new unknowns is the universal adapter (see Reducing higher-order ODEs to first-order systems).

Why is the local error

O (h^{5})

but the global error only

O (h^{4})

You accumulate roughly

1/ h

steps to cross a fixed interval, so the per-step

O (h^{5})

errors add up to about

(1/ h) \cdot O (h^{5}) = O (h^{4})

(detailed in Local vs Global Truncation Error).

Why can explicit RK4 still fail badly on some systems despite its high order?

On stiff systems the stability region of explicit RK4 forces impractically tiny

h

, so accuracy is fine but you'd need enormous computation to stay stable (see Stiff systems and stability).

Why does the same numerical answer appear for the

2 \times 2

system

y_{1}^{'} = y_{2}, y_{2}^{'} = - y_{1}

and for the reduced

y^{''} + y = 0

Because they are the same equations — the reduction of

y^{''} + y = 0

produces exactly

u_{1}^{'} = u_{2}, u_{2}^{'} = - u_{1}

, so RK4 sees identical right-hand sides and produces identical steps.

Edge cases

Boundary and degenerate scenarios you must not be surprised by.

What happens if the system is

1 \times 1

(a single equation) run through RK4-for-systems?

It reduces exactly to scalar RK4 for a single ODE — the vector of length one is just a number, so the two methods coincide with no special-casing.

f

does not depend on

t

(an autonomous system), do we still pass the shifted times

t_{n} + \frac{h}{2}

The time arguments still exist in the formula but

f

ignores them, so effectively only the state shifts matter; the recipe is unchanged and correct.

For a linear system

y^{'} = A y

, are the

k_{i}

still needed, or is there a shortcut?

RK4 still applies verbatim (each

k_{i} = A \times (state

)); a closed-form via the matrix exponential exists too, but RK4 needs no such special structure and works identically whether or not

A

is constant.

What if one component's initial value is exactly

0

— does that break any stage?

No — a zero entry is a perfectly valid state value; the slopes and averages are computed the same way, so zeros propagate through the arithmetic without any special handling.

If a component reaches a fixed point (its slope is

0

there), does RK4 leave it unchanged?

If all four

k_{i}

vanish for that component it stays put; but if coupling makes any midpoint slope nonzero, it can still drift, so a true equilibrium requires the slope to be zero throughout the whole predicted step, not just at the start.

What does taking

h \to 0

do to both the accuracy and the cost?

Accuracy improves like

h^{4}

but the number of steps (and

f

-evaluations, four per step) grows like

1/ h

, so there is a practical trade-off — shrinking

h

forever eventually just accumulates round-off error, not precision.

If two stages accidentally receive the same state (e.g.

k_{1}

happens to be zero), are

k_{2}

and

k_{3}

still valid?

Yes — a zero

k_{1}

simply means the midpoint state equals

y_{n}

, so

k_{2}

evaluates there legitimately; nothing degenerates, the method just samples fewer distinct states this step.

Connections

Parent topic — RK4 for systems
RK4 for a single ODE — the scalar case these traps generalise.
Euler's method for systems — what "use only $k_{1}$ " collapses to.
Reducing higher-order ODEs to first-order systems — the adapter behind the edge cases.
Local vs Global Truncation Error — the $O (h^{5}) \to O (h^{4})$ reasoning.
Stiff systems and stability — why order 4 alone is not enough.
Simpson's Rule — the source of the $1, 2, 2, 1$ weights.