Question bank — Implementing ODE solvers from scratch — Euler, RK4

True — they are IVP solvers; without a starting value there is nothing to step forward from, since each step reads the slope at the current point. See scipy.integrate.solve_ivp which also demands y0.

True — Euler's global error is $O(h)$, so error scales linearly with $h$; cut $h$ in two and error drops by about $2$.

False — RK4 is $O(h^4)$, so halving $h$ cuts error by about $2^4=16\times$, not $2\times$.

False — it is fourth-order accurate, not exact; it discards the $O(h^5)$ local terms and still accumulates global $O(h^4)$ error unless the true solution is a polynomial of degree $\le 4$ that RK4 can integrate exactly.

True in function evaluations — RK4 calls $f$ four times per step vs Euler's one, but this is the wrong metric: at equal accuracy RK4 needs vastly fewer steps and wins overall.

False — $f$ depends on $t$ here (non-autonomous), so $k_2,k_3$ must use $t+\frac{h}{2}$ and $k_4$ must use $t+h$; skipping them corrupts the answer.

False — Simpson uses $(1,4,1)$ over three points; RK4 uses $(1,2,2,1)$ over four stages, with two midpoint evaluations whose weights sum to $2+2=4$ — analogous, not identical. See Simpson's Rule.

True — rearranging the forward difference $\frac{y_{n+1}-y_n}{h}\approx f(t_n,y_n)$ gives exactly the Euler update. See Finite Difference Approximation of Derivatives.

False — beyond a stability limit, large $h$ makes explicit Euler and RK4 blow up (oscillate to infinity), especially on stiff problems. See Numerical Stability and Stiff ODEs.

Wrong — $k_3$ must use the previous stage $k_2$: $k_3=f(t+\frac{h}{2},y+\frac{h}{2}{k}_2)$. The stages are a chain; reusing $k_1$ collapses RK4 to a lower order and silently destroys the $O(h^4)$ accuracy.

Wrong — the weights are $1,2,2,1$ (sum $6$), so you divide by $6$: $y_{n+1}=y_n+\frac{h}{6}(k_1+2k_2+2k_3+k_4)$. A plain average by 4 gives the wrong weighted mean and loses accuracy.

Wrong — Euler samples only at the left endpoint $(t_n,y_n)$ and assumes it holds all the way across; sampling at the midpoint would be a different (better) method.

Wrong — you add $\frac{h}{2}{k}_1$, not $\frac{h}{2}$; the nudge to $y$ must be scaled by the slope $k_1$, since $y$ changes by (slope × step), not by the step alone.

Wrong — Euler gives $y_1=1+1\cdot 1=2$, an error of $\approx 0.718$; only the true solution equals $e$, and Euler's straight-line hop undershoots the curving exponential.

Wrong — RK4's local truncation error is $O(h^5)$; the global error (accumulated over $N=T/h$ steps) is $O(h^4)$. Don't confuse the two.

Because it trusts a single left-endpoint slope for the whole step; if the curve bends upward the straight line lies below it (and vice versa), so errors accumulate in one direction rather than cancelling.

The midpoint best represents the average slope over the interval; a first midpoint estimate $k_2$ (built from $k_1$) is refined by a second $k_3$ (built from $k_2$), and giving each weight $2$ matches the Taylor series through $h^4$.

Because expanding the RK4 update as a Taylor series and demanding it agree with the true $y(t_n+h)$ up to the $h^4$ term produces these coefficients uniquely — they are not a free choice. See Taylor Series Expansion.

At a target error $\epsilon$, Euler cost scales like $1/\epsilon$ while RK4 scales like $1/{\epsilon }^{1/4}$; for small $\epsilon$ RK4 needs astronomically fewer total evaluations.

Most real $f(t,y)$ have no closed-form integral, but the slope $f$ itself is always computable, so we walk forward in small computable hops.

Because $\frac{h}{6}(k_1+2k_2+2k_3+k_4)$ is a genuine weighted mean slope (weights sum to $6$) times $h$; any other divisor would mis-scale the step and break the order.

No progress — $t_{n+1}=t_n$ and $y_{n+1}=y_n$; the solver stands still forever, so a positive step size is mandatory.

No — since $f$ ignores $t$, evaluating at $t$, $t+\frac{h}{2}$, or $t+h$ makes no difference; the $t$-shifts only matter for non-autonomous $f(t,y)$.

It becomes exact — the true solution is a straight line $y_0+ct$, and Euler's straight-line hop matches it perfectly with zero truncation error for any $h$.

Explicit methods have a bounded stability region; if $h$ times the (large negative) rate lies outside it, the numerical solution oscillates and grows without bound even though the true solution decays. Fix with implicit methods or adaptive stepping. See Numerical Stability and Stiff ODEs.

It is exact — RK4 integrates polynomials up to degree $4$ with no error, since the discarded terms start at $h^5$ and a cubic has no such terms.

Fixed-step Euler/RK4 will happily step over the singularity and return garbage; you need adaptive step control to detect the blow-up and refuse to cross it. See Adaptive Step Size (RK45 / Dormand–Prince).

Not indefinitely — past a point, floating-point round-off from summing many tiny increments dominates, so error bottoms out and then slowly worsens as $h$ shrinks further.