The Heaviside Step and Switching Forces On

Inputs that turn on partway through

You arrived in this rung with a working machine. Given an initial value problem, you transform it with L{y'} = sY - y(0), solve the algebra for Y(s), and run the master algorithm back home with the transform table. So far every forcing function on the right-hand side has been a single tidy formula valid for all time — a constant, an e^(a t), a sine. But the inputs that actually make the Laplace transform worth the trouble are the rough ones: a switch flipped at t = 2, a battery connected then disconnected, a steady weight suddenly set down on a beam.

Such inputs are described in pieces: zero before some time, then something after. We call them piecewise forcing functions, and the old guess-and-match recipe for nonhomogeneous equations chokes on them, because the right-hand side is not one formula. The honest first reaction is to solve the equation separately on each interval and then painstakingly glue the solutions so that y and y' match at every switching instant. That works, but it is fiddly and error-prone. The Laplace method offers something far cleaner: a way to write the whole switched input as one expression and run it through the machine in a single pass.

The cleanest on-switch there is

The whole trick rests on one elementary function. The Heaviside step, written u(t) or sometimes H(t), is 0 for t < 0 and 1 for t >= 0. Picture a light switch: off, then on, with the flip at t = 0. To move the flip to a later moment a, you simply shift the argument: the Heaviside step u(t - a) is 0 until t reaches a, then jumps to 1 and stays there. That single object is your on-switch, and you can place it anywhere on the time axis just by choosing a.

Now multiply. If g(t) is some signal and you want it to appear only from time a onward, write u(t - a) * g(t): before a the step is 0, killing the product; after a the step is 1, letting g through untouched. Multiplying by a step is exactly the act of switching a force on. Subtract two steps and you carve out a window — u(t - a) - u(t - b) is 1 only between a and b, an input that turns on at a and off again at b. With these blocks any on-off switching input you can describe in words, you can now write as a formula.

u(t)        = 0 for t < 0,   1 for t >= 0       (the on-switch at 0)
u(t - a)    = 0 for t < a,   1 for t >= a       (on-switch at time a)

u(t - a) g(t)            ->  g switched ON at t = a
u(t - a) - u(t - b)      ->  a window: ON at a, OFF at b   (a < b)

L{ u(t - a) } = e^(-a s) / s          (a >= 0)

Delay in t becomes a factor in s

Here is the rule that makes all of this pay off, and it is the heart of the guide. Suppose you already know the transform of g(t) is G(s). What is the transform of the same signal delayed and switched on at time a, namely u(t - a) * g(t - a)? The answer is the second shifting theorem: L{ u(t - a) g(t - a) } = e^(-a s) * G(s). A delay by a in the time domain becomes nothing more than multiplication by e^(-a s) in the s-domain. Shifting a signal later in time costs you exactly one exponential factor — no new integral, no new table entry.

It is worth feeling why the e^(-a s) appears, because it is not a coincidence. The transform integrates e^(-s t) against your signal from 0 onward. A signal that is silent until a and then runs is, under the integral, the original signal with its clock pushed forward by a. Substituting to line the clocks back up pulls a constant e^(-s a) straight out of the integral, leaving the original G(s) behind. The delay and the exponential are two faces of the same shift; once you see that, the rule stops being a thing to memorise and becomes something you could rederive.

Carrying a switched problem there and back

Now the pieces lock together. To solve an ODE with a piecewise input, you first write the right-hand side using Heaviside steps so it is one clean formula, transform the whole equation, and solve for Y(s) exactly as before. The only new feature is that Y(s) now carries one or more e^(-a s) factors riding along — the algebraic fingerprints of the switching times. You do the s-domain algebra ignoring those factors, treating each e^(-a s) * (something) as a delayed copy to be dealt with at the end.

1. Rewrite the piecewise input as one formula using Heaviside steps, e.g. a force on between a and b becomes [u(t - a) - u(t - b)] times its strength.
2. Transform the whole ODE; each delayed term contributes an e^(-a s) factor times an ordinary transform.
3. Solve for Y(s) algebraically, carrying the e^(-a s) factors along untouched.
4. Invert each piece with the table; wherever an e^(-a s) sits in front, the inverse gets a u(t - a) and every t inside is shifted to (t - a).

That last step is the second shifting theorem read backwards, and it is where the answer reassembles itself into pieces. The solution comes out already in switched form — a base response, plus a delayed correction that switches on exactly at each a — with no manual gluing of intervals and no matching of y and y' by hand. The continuity that cost you sweat in the interval-by-interval approach is built in automatically, because everything was carried through a single linear pipeline. You can spot-check the result against the transform table and against common sense: before the first switching time, the delayed terms are all zero, so the early solution should match the un-switched problem.

Where this matters, and one honest caution

This is not a paper exercise. The cleanest place it pays off is the switched circuit: connect a battery to an RLC loop at t = 0, disconnect at t = 5, and the driving voltage is exactly a windowed step. The same picture describes a thermostat cutting heat on and off, a motor commanded with a square pulse, or a structure loaded then unloaded. In every case you are studying an input-output system whose input is a sequence of switches, and the step function is the natural alphabet for writing that input down.