Final Value Theorem: lim(t→∞) y(t) = lim(s→0) sY(s)

What does the Final Value Theorem tell you?

The Final Value Theorem (FVT) tells you the steady-state value of a time-domain signal y(t) as t→∞ by evaluating a limit of its Laplace transform Y(s) as s→0 — no inverse transform, no simulation, no waiting. You get the number the system settles to with one line of algebra, provided the system actually settles.

Definition and mathematical statement

The theorem states: lim(t→∞) y(t) = lim(s→0) sY(s), subject to validity conditions covered in the next section. Y(s) is the Laplace transform of y(t), and multiplying by s before taking the s→0 limit is what extracts the DC (steady-state) content of a signal that may otherwise blow up or oscillate in the transform domain. This is purely an algebraic operation on a rational function — you plug in s = 0 after cancellation and read off a number.

Why it matters in control system design

FVT collapses a question that would otherwise require running a simulation to t = 10×(time constant) or more into a single limit evaluated by hand or in a CAS. During design iteration — tuning a PID gain, picking a feedback resistor ratio, sizing a compensator zero — you want to know immediately whether a candidate design drives steady-state error to zero or leaves a residual offset, without re-running a transient simulation for every parameter tweak. FVT gives you that answer directly from the transfer function's algebraic structure: the number of integrators (poles at the origin) in the loop and the DC gain are all you need.

Relationship to steady-state error and performance

Steady-state error, Ess, is one of the five numbers used to grade any closed-loop response, alongside rise time, overshoot, settling time, and peak time, as covered in Performance Specs: %OS, Ts, Tr, Tp, Ess (Steady-State Error). FVT is the computational tool that produces the Ess number: you apply it to the error signal E(s) rather than the output Y(s), and the result tells you whether your loop tracks a step, ramp, or parabolic command with zero, finite, or infinite offset.

When is the Final Value Theorem valid and when does it fail?

FVT only gives the correct answer when sY(s) has all its poles strictly in the open left half-plane, with at most one pole permitted at s = 0 (the one being cancelled by the multiplying s). Violate that condition and the formula still produces a number — but that number is meaningless.

Pole location constraints: why poles must be in left half-plane

A pole at s = -a (a > 0) corresponds to a decaying exponential e^(-at), which has a well-defined limit of zero as t→∞. A pole in the right half-plane, s = +a, corresponds to e^(+at), which diverges. FVT's derivation relies on being able to integrate y(t)e^(-st) and let s→0 while the signal itself stays bounded; if the signal is unbounded, the integral and the limit interchange that the proof depends on no longer holds. The rule of thumb: factor the denominator of sY(s), find every root, and confirm each one has negative real part before trusting the result.

Poles on imaginary axis: marginally stable systems

A pair of poles at s = ±jω₀ produces a sustained sinusoid, sin(ω₀t), which never converges to a single value — it oscillates forever. Applying the FVT formula mechanically to such a Y(s) yields a finite-looking number, but that number is not a limit of y(t) because no such limit exists. This is the single most common FVT trap: the algebra doesn't warn you that the limit doesn't exist; you have to check pole locations yourself before trusting the output.

Poles in right half-plane: divergent and unstable responses

If sY(s) has any pole with positive real part, y(t) contains a growing exponential term and has no finite steady-state value at all. Mechanically applying the limit here produces either a finite but wrong number or an indeterminate form, and either way it's useless as a design number — an unstable system doesn't have a steady state to compute.

Common failure cases and how to recognize them

Before trusting any FVT result, run the denominator of sY(s) through a stability check — Routh-Hurwitz on the characteristic polynomial, or just factor it if it's low order. This is a thirty-second check that saves you from reporting a steady-state value for a system that actually rings or diverges.

How to apply FVT to step, ramp, and impulse inputs

The procedure is the same every time: form Y(s) = G(s)·U(s), multiply by s, cancel, substitute s = 0.

Step input: finding DC steady-state gain

A unit step has U(s) = 1/s, so Y(s) = G(s)/s and sY(s) = G(s). The steady-state value is simply G(0), the DC gain of the transfer function — read directly off the transfer function with s set to zero, no cancellation needed beyond the step's own 1/s.

Ramp input: detecting velocity error in Type 1 systems

A unit ramp has U(s) = 1/s², so sY(s) = G(s)/s. If G(s) has no pole at the origin (Type 0), this limit is infinite — the system can't track a ramp at all. If G(s) has exactly one pole at the origin (Type 1), the s in the denominator cancels with the remaining s and you get a finite velocity error constant.

Parabolic input: acceleration error in Type 2 systems

A unit parabola has U(s) = 1/s³. Tracking it with finite error requires two poles at the origin in G(s) (Type 2). The pattern generalizes: each additional free integrator in the open loop buys you one more polynomial order of input tracked with finite, nonzero error.

Input transform forms: sU(s) multiplication rule

The rule you're always executing is lim(s→0) s·G(s)·U(s). Keep U(s) symbolic (1/s, 1/s², 1/s³ for step, ramp, parabola) and simplify algebraically before substituting s = 0 — substituting too early produces 0/0 or ∞/∞ indeterminate forms that look like failures but are really just premature evaluation.

How does FVT connect to steady-state error specifications?

FVT applied to the error signal E(s) = R(s) - Y(s), rather than to Y(s) itself, is how Ess gets computed from a transfer function without ever simulating the closed loop.

Using FVT to calculate Ess directly from transfer function

For unity-feedback loop gain G(s) and reference R(s), E(s) = R(s)/(1+G(s)). Applying FVT: Ess = lim(s→0) sR(s)/(1+G(s)). For a unit step, Ess = 1/(1+G(0)) — directly computable once you know G(0), no need to solve the closed-loop ODE.

Relating system type and error constants to FVT results

The error constants Kp (position), Kv (velocity), Ka (acceleration) are just shorthand for the FVT limits evaluated for step, ramp, and parabolic inputs respectively — Kp = lim(s→0) G(s), Kv = lim(s→0) sG(s), Ka = lim(s→0) s²G(s). System type (the count of open-loop poles at the origin) determines which of these constants is finite and which are zero or infinite, and that in turn determines whether Ess for a given input is zero, a finite nonzero fraction, or infinite.

Verifying performance specs without closed-loop simulation

If a spec calls for Ess < 2% to a step command, you compute G(0) algebraically from your compensator and plant model, form 1/(1+G(0)), and compare against 0.02 — a closed-form check that takes seconds and that you can re-run instantly as you adjust compensator gain, before committing to a full simulation run.

Practical worked examples: first-order and second-order systems

First-order system response to step input

Take G(s) = 5/(s+2) with a unit step input, open loop (no feedback). Y(s) = 5/[s(s+2)]. sY(s) = 5/(s+2). At s=0: 5/2 = 2.5. The pole at s = -2 is in the left half-plane, so this is valid — the response settles at 2.5, matching 5×(step amplitude)/2, the DC gain.

Feedback system with integrator: verifying zero steady-state error

Take open-loop G(s) = 10/[s(s+3)] in unity feedback, step input. Closed-loop E(s) = R(s)/(1+G(s)) = (1/s)/(1 + 10/[s(s+3)]) = (s+3)/[s(s+3)+10] = (s+3)/(s²+3s+10). sE(s) = s(s+3)/(s²+3s+10). At s=0: 0. Check poles of s²+3s+10: roots at s = (-3 ± √(9-40))/2, both with negative real part (-1.5 ± j2.78 rad/s) — stable, so Ess = 0 is trustworthy. The single open-loop integrator, as the system-type analysis predicts, zeroes out step error.

Disturbance rejection: applying FVT to error signal

For a plant G(s) with a step disturbance D(s) = 1/s entering at the plant input and unity feedback with controller C(s), the error due to disturbance alone is E(s) = -G(s)D(s)/(1+C(s)G(s)). Apply FVT the same way: form sE(s), cancel the disturbance's 1/s, substitute s=0, and check that poles of 1+C(s)G(s) are all left-half-plane before trusting the result. A controller with an integrator (C(s) containing 1/s) drives this limit to zero, rejecting constant disturbances entirely — the same mechanism that zeroes step tracking error.

How FVT compares to the Initial Value Theorem

Dual relationship: t→∞ vs. t→0⁺

The Initial Value Theorem (IVT) states lim(t→0⁺) y(t) = lim(s→∞) sY(s) — the mirror image of FVT, probing the signal's value the instant after an input is applied rather than its eventual settling point. Where FVT sends s→0, IVT sends s→∞; where FVT needs left-half-plane poles to be valid, IVT has milder requirements (it works for proper rational Y(s) regardless of pole location, since it's asking about t=0⁺, not t=∞).

Using both theorems to bracket system behavior

Together the two theorems give you the two endpoints of a response — where it starts and where it ends — without computing a single intermediate point. For the earlier first-order example, Y(s) = 5/[s(s+2)] for a unit step: IVT gives lim(s→∞) s·5/[s(s+2)] = lim(s→∞) 5/(s+2) = 0, confirming the response starts at zero, while FVT gave 2.5 as the settled value. Knowing both endpoints is often enough to sanity-check a simulation plot at a glance — if your simulated curve doesn't start and end at these two numbers, something in the model is wrong.

When to use each theorem in design workflow

Use IVT when you need to confirm initial conditions or check for impulsive/discontinuous behavior at t=0 (useful for verifying a transfer function's relative degree), and use FVT whenever the question is steady-state accuracy — DC gain, Ess, disturbance rejection — which is the overwhelming majority of control design checks. Neither theorem tells you about the transient between the endpoints: overshoot, rise time, and settling time still require either simulation or the pole/zero analysis.

Common mistakes and debugging FVT calculations

Forgetting to multiply by s before taking limit

Taking lim(s→0) Y(s) instead of lim(s→0) sY(s) is the most frequent arithmetic error — Y(s) itself typically has a pole at s=0 from the input transform, so evaluating it directly gives ∞ instead of the finite steady-state value. Always write out sY(s), simplify algebraically, and only then substitute.

Misidentifying pole locations on stability boundary

A quadratic denominator like s² + ω₀² has roots at s = ±jω₀, easy to miss if you only glance at the coefficients instead of factoring or running Routh-Hurwitz — there's no s¹ term, which is itself a red flag for marginal stability. Any time a denominator coefficient is zero or the polynomial looks "too clean," factor it explicitly before applying FVT.

Applying FVT to inherently oscillatory or divergent signals

You cannot apply FVT directly to a closed-loop transfer function without first confirming closed-loop stability — a closed-loop Y(s) formed from an unstable or marginally stable characteristic equation will still produce a numeric output from the limit formula, and that number is simply wrong, not a warning. Treat the pole-location check as a mandatory precondition, not an optional step: run it before reporting any FVT result, especially when the transfer function comes from an automated model-generation tool rather than hand derivation.

Related reading

• Initial Value Theorem: lim(t→0⁺) y(t) = lim(s→∞) sY(s) — checking the other endpoint of a response.
• First-Order Step Response: Rise Time, Settling Time — verifying settling behavior against the predicted limit.