Stiff equations — implicit methods, backward Euler: Question bank

Every symbol here comes from the parent note:

$y^{'} = λ y$ is the test problem — a single ODE whose true solution is $y (t) = y_{0} e^{λ t}$ .
$λ$ (lambda) is a number that sets the speed of decay; $λ < 0$ means the solution shrinks toward zero.
$λ$ may also be a complex number $λ = a + bi$ . Its real part is written $Re λ = a$ — the part with no $i$ attached. Geometrically, if you plot $λ$ as a point on a plane (horizontal axis = real part, vertical axis = imaginary part), $Re λ$ is its horizontal coordinate. A negative real part ( $Re λ < 0$ ) means the point sits in the left half of that plane, and the true solution decays.
$h$ is the step size — how far in time we jump each step.
$y_{n}$ is our numerical guess after $n$ steps; $y_{n + 1}$ is the next one.
The amplification factor is the number we multiply $y_{n}$ by to get $y_{n + 1}$ . Forward Euler's is $1 + hλ$ ; backward Euler's is $\frac{1}{1 - hλ}$ . If its size (absolute value) is below $1$ , the numerical solution shrinks — that is stability.

True or false — justify

Backward Euler is more accurate than forward Euler.

False. Both are first-order,

O (h)

— the same accuracy order. Backward Euler's advantage is stability, a completely separate axis from accuracy.

A stiff problem is just a problem that needs a very small step size.

False. It needs a tiny step only for explicit methods, and only for stability, even where the true solution is smooth and slow. Stiffness is about clashing time scales, not raw difficulty.

If the true solution decays to zero, forward Euler's numerical solution must also decay to zero.

False. Only if

∣1 + hλ ∣ < 1

. With

λ = - 100, h = 0.05

we get

1 + hλ = - 4

, so

y_{n} = (- 4)^{n}

blows up while the true

e^{- 100 t} \to 0

Backward Euler is stable for every ODE no matter what.

False. It is A-stable: unconditionally stable when

Re λ < 0

(decaying problems). For a growing problem (

Re λ > 0

) the true solution grows, and it would be wrong to force it to zero.

For

y^{'} = λ y

with

λ < 0

, backward Euler's amplification factor

\frac{1}{1 - hλ}

is always a positive number less than

1

True. With

λ < 0

and

h > 0

1 - hλ > 1

, so its reciprocal is a positive number strictly below

1

— hence decay for any step size.

Making an explicit method implicit automatically makes it A-stable.

False. Being implicit permits large stability regions but doesn't guarantee A-stability — you must analyse the specific method's amplification factor to know.

The trapezoidal (Crank–Nicolson) method, being implicit, will damp a very stiff mode to zero just like backward Euler.

False. Trapezoidal is A-stable but not L-stable: for very negative

λ

its factor

\to - 1

, so stiff modes ring at amplitude

1

instead of vanishing. Backward Euler's factor

\to 0

, killing them.

Choosing

h

for backward Euler on a stiff problem is about survival, not accuracy.

False. Since backward Euler survives any

h > 0

, the step is chosen purely for accuracy — the exact freedom stiffness denies to explicit methods.

Spot the error

"Backward Euler amplification is

1 - hλ

, so with

λ < 0

it grows — that can't be right."

The error is the formula. Backward Euler gives

(1 - hλ) y_{n + 1} = y_{n}

, so the factor is

\frac{1}{1 - hλ}

— the reciprocal. That is below

1

, so it decays.

"For

λ = - 1000

, forward Euler needs

h < 2/1000

only during the fast transient; afterwards I can grow

h

Wrong. The stability cap

h < 2/∣ λ ∣

depends on

λ

, which never changes. Even after the fast mode has died, forward Euler is still forced to take tiny steps forever.

"Fixed-point iteration

y^{(k + 1)} = y_{n} + h f (t_{n + 1}, y^{(k)})

solves the implicit step fine, so why bother with Newton?"

Fixed-point iteration converges only if

∣ h \partial f / \partial y ∣ < 1

, where the partial derivative

\partial f / \partial y

is evaluated at the step's point

(t_{n + 1}, y_{n + 1})

— the exact stiff restriction we wanted to escape. Newton has no such limit, preserving large steps.

"Since implicit methods do more work per step, they must be slower overall for stiff problems."

Wrong overall count. Explicit methods need thousands of tiny steps (e.g.

\geq 5000

to reach

t = 10

with

λ = - 1000

); implicit ones need ~

100

big steps, so implicit wins despite costlier steps.

"Forward Euler at

λ = - 100, h = 0.05

gives

y_{1} = - 4

, which is negative, but that's still stable because it's shrinking below

y_{0}

The sign flip is the warning.

∣1 + hλ ∣ = ∣ - 4∣ = 4 > 1

; the size grows each step (

1, 4, 16, \dots

), so it is unstable and oscillating — magnitude, not sign, decides stability.

"Backward Euler always undershoots the true solution, so it introduces no oscillation."

Not "always undershoots," but the useful truth: its factor

\frac{1}{1 - hλ}

stays a positive number in

(0, 1)

for

λ < 0

, so it produces monotone decay with no sign oscillation — unlike forward Euler.

Why questions

Why do we study the single scalar test problem

y^{'} = λ y

instead of a real system?

Because a linear system diagonalises into independent scalar equations, one per eigenvalue

λ

. Stability of the whole system reduces to the scalar rule applied to each

λ

Why does "more negative

λ

" mean "stiffer"?

The true mode is

e^{λ t}

; more negative

λ

decays faster, so it sets a shorter time scale, which tightens the explicit stability cap

h < 2/∣ λ ∣

while the slow modes still need long integration.

Why does backward Euler evaluate

f

at the new point

t_{n + 1}

rather than the old one?

So the unknown

y_{n + 1}

appears inside

f

, making the update implicit. Aiming at the future point is exactly what forces

y_{n + 1}

into the calm region, buying unconditional stability.

Why is A-stability described as "covering the entire left half-plane"?

Think of

z = hλ

as a point plotted on the plane (horizontal = real part, vertical = imaginary part). Backward Euler is stable exactly where

∣1/ (1 - z) ∣ < 1

, i.e.

∣1 - z ∣ > 1

. The point

1 - z

z

reflected and shifted so it sits a distance

∣1 - z ∣

from the origin; that distance exceeds

1

for every

z

left of the vertical axis. So the whole shaded region is the left half-plane

Re (z) < 0

— precisely where the true solution decays.

Why can't we just shrink

h

to fix a stiff explicit run?

You can in principle, but the required

h

is absurdly small (millions of steps), making it hopelessly slow. Stiffness is precisely the signal to change method, not step size.

Why is Newton's method natural here even though the ODE step is "just one equation"?

Because for nonlinear

f

we define the residual function

g (y) = y - y_{n} - h f (t_{n + 1}, y)

, whose root

g (y) = 0

is the implicit step. Newton then updates using its slope

g^{'} (y) = 1 - h \partial f / \partial y

, converging fast regardless of stiffness.

Why do we care about stability separately from accuracy at all?

Accuracy controls how close

y_{n}

is to the true value; stability controls whether errors grow or shrink over many steps. An unstable method is useless no matter how accurate its formula's order.

Edge cases

What happens to forward Euler exactly at

h = 2/∣ λ ∣

(so

1 + hλ = - 1

The factor has size exactly

1

, so

y_{n} = (- 1)^{n} y_{0}

oscillates forever at constant amplitude — marginally stable, neither decaying nor exploding. The strict inequality

∣1 + hλ ∣ < 1

is not met.

What does backward Euler do in the limit

h \to \infty

y^{'} = λ y, λ < 0

The factor

\frac{1}{1 - hλ} \to 0

, so

y_{1} \to 0

in one step. It slams stiff modes to zero — this strong damping is L-stability.

What if

λ = 0

(a constant, non-decaying solution)?

Backward Euler's factor is

\frac{1}{1 - 0} = 1

and forward Euler's is

1 + 0 = 1

; both preserve the constant exactly. Neither grows nor shrinks it, which is correct since

y^{'} = 0

What if

λ

is complex with

Re λ < 0

(oscillatory decay)?

Write

z = hλ

; then

Re (z) < 0

, so

1 - z = 1 - Re (z) - i Im (z)

has real part

1 - Re (z) > 1

. A complex number whose real part already exceeds

1

must be at least distance

1

from the origin (its magnitude is

(real)^{2} + (imag)^{2} \geq ∣ real ∣ > 1

), so

∣1 - z ∣ > 1

and

∣1/ (1 - z) ∣ < 1

— stable. This is why A-stability is stated over the whole left half-plane, not just the real axis.

What if

Re λ > 0

— should a good method still drive

y_{n} \to 0

No. The true solution grows, so a faithful method must let

y_{n}

grow too. "Stability" for a growing problem means matching that growth, not forcing decay.

For a system with eigenvalues

λ = - 1

and

λ = - 1 0^{6}

, which one caps an explicit step?

The most negative one,

λ = - 1 0^{6}

, forces

h < 2/1 0^{6}

— the fastest mode always dictates the explicit step, which is the essence of stiffness.

Recall One-line summary of the whole trap-set

Stability and accuracy are different axes; stiffness is a time-scale clash; backward Euler wins by aiming at the future, damping stiff modes to zero for any step size.

Connections — what each linked note adds here

Forward Euler method — the explicit baseline whose factor $1 + hλ$ and cap $h < 2/∣ λ ∣$ we keep contrasting against.
Region of absolute stability — the plotted shaded set of $hλ$ where a method stays bounded; this whole page is about its shape.
A-stability and L-stability — names the two levels of "good": A-stable = covers the left half-plane; L-stable = also kills stiff modes to zero.
Trapezoidal / Crank–Nicolson method — the A-stable-but-not-L-stable cousin whose factor rings at $- 1$ instead of vanishing.
Newton's method for root finding — the engine that solves the implicit step's residual $g (y) = 0$ without the stiff step cap.
Runge–Kutta methods — higher-order schemes that can be made implicit/A-stable to combine accuracy with stiff stability.
Eigenvalues and time scales of linear systems — supplies the $λ$ values; the most negative eigenvalue sets the stiffness.

Question bank — Stiff equations — implicit methods, backward Euler

True or false — justify

Spot the error

Why questions

Edge cases

Connections — what each linked note adds here

Connection map