One messy push, several tidy ones
By now you can drive a second-order equation with a single clean forcing: a polynomial, an exponential, a sine, a cosine. You guess a particular solution of the matching shape, fix its coefficients, and patch up any collision with y_c using the resonance rule. But real pushes are rarely one clean shape. A circuit might be driven by 5 + 2 e^(-x) sin(3x); a spring might feel a constant pull plus a periodic shove. Staring at a forcing function like g(x) = 4 x^2 + 7 e^(2x), what single trial shape could you possibly write?
The answer is: you don't write one. You split the push. Whenever g is a sum of pieces, g = g1 + g2 + ... + gk, you find a particular solution for each piece separately and then add them. The single-shape methods you already own — undetermined coefficients for nice shapes, and the heavier machinery when guessing fails — each handle one tidy term at a time, and this guide is the rule that lets you point them at a sum.
Why adding the answers is allowed
The licence comes, as always in this rung, from the operator L being linear. Suppose y_p1 solves L[y] = g1 and y_p2 solves L[y] = g2 — two separate forced problems, each with its own particular solution. Now add the two functions and feed the sum through L. Linearity lets the operator distribute across the sum: L[y_p1 + y_p2] = L[y_p1] + L[y_p2] = g1 + g2. The sum of the answers solves the equation forced by the sum of the pushes. That one line is the entire superposition of forcing terms.
It is worth seeing this as a second face of the same coin you met earlier. Back in guide one, the superposition principle let you add two homogeneous solutions and stay homogeneous; here you add two particular solutions and the right-hand sides add too. Same engine, different output. In fact you can fold both facts into one statement: for the linear operator L, the response to a sum of inputs is the sum of the responses to each input. Engineers call exactly this property linearity of a system, and it is the reason whole theories — frequency response, transfer functions — can decompose any input and reassemble the output.
L[y] = g1 + g2 + ... + gk (split the forcing)
L[y] = g1 -> y_p1
L[y] = g2 -> y_p2
... ...
L[y] = gk -> y_pk
-----
y_p = y_p1 + y_p2 + ... + y_pk
full answer: y = y_c + y_p
The recipe, step by step
In practice the method reads like a short checklist. Take the example L[y] = 4 x^2 + 7 e^(2x). The forcing is already a sum of two friendly shapes, so you split it as g1 = 4 x^2 and g2 = 7 e^(2x), solve each with undetermined coefficients, and add. Here is the full loop you run every time.
- Find y_c once. Set the right side to zero, solve the characteristic equation, and write the complementary solution. This depends only on a, b, c and is shared by every piece.
- Split the forcing into natural pieces g1, g2, ..., gk — one per distinct shape (each polynomial, each exponential, each sine/cosine group).
- For each gi solve L[y] = gi on its own, getting a particular solution y_pi. Treat the resonance/duplication check piece by piece — compare each gi against y_c separately.
- Add the particular solutions: y_p = y_p1 + y_p2 + ... + y_pk.
- Assemble y = y_c + y_p, and only now fit the two arbitrary constants to the initial conditions y(0), y'(0).
Notice where the complementary solution sits in that loop: it is computed in step one and added in step five, exactly once, never per piece. A very common slip is to carry a copy of y_c (and its two constants) into each sub-problem and then sum them, ending up with a tangle of constants. There is only ever one general solution structure y = y_c + y_p with two constants total, no matter how many forcing pieces you superposed.
Resonance is checked piece by piece
The subtlest point in the whole method is the resonance rule, and superposition does not let you skip it — it makes you apply it more carefully. Each piece gi gets its own duplication check against the complementary solution. One term might collide with y_c and need the extra factor of x from the modification rule, while its neighbour, a different shape entirely, sails through untouched. You must judge each forcing term on its own; a clash in one piece says nothing about the others.
A small concrete picture. Suppose y_c = C1 cos(x) + C2 sin(x), and you are forced by g = e^(2x) + 3 sin(x). The first piece, e^(2x), is nowhere in y_c, so its trial A e^(2x) needs no fix. The second piece, 3 sin(x), is exactly a complementary shape — pure resonance — so its trial must be bumped to x(A cos x + B sin x). Solve the two sub-problems, add their answers, and the resonant piece quietly contributes the growing-amplitude term that physical resonance demands, while the other piece stays bounded. Superposition keeps these two fates from contaminating each other.
How far superposition reaches — and where it stops
Superposition pairs beautifully with both particular-solution methods, not just guessing. If one piece is a friendly polynomial-exponential-trig shape, handle it with undetermined coefficients; if a different piece is something ugly that no finite guess fits — a secant, a logarithm, a piecewise pulse — hand that single piece to variation of parameters, which always works, and superpose its answer with the rest. You are free to mix methods across pieces. This is how a forcing like g = sec(x) + e^x gets solved: variation of parameters for the secant, undetermined coefficients for the exponential, then add.
Be honest about the two boundaries of this convenience. First, superposition is strictly a gift of linearity: it works because L distributes over sums. The moment the equation is nonlinear — a (y')^2 term, a product y y', anything not of the form (constant)·(derivative of y) — adding the answers no longer yields an answer, and breaking g into pieces buys you nothing. Forced nonlinear equations simply do not decompose this way. Second, the rule covers a finite sum of pieces; extending it to an integral of infinitely many infinitesimal pushes (writing the response as a convolution against an impulse response) is a real and powerful idea, but it belongs to the later Laplace-transform rung, not here.
Stand back and see what this rung built. The structure theorem said y = y_c + y_p; undetermined coefficients and the resonance rule found y_p for clean single shapes; variation of parameters found it when guessing failed; and superposition now lets all of that loose on forcings that are sums of pieces. Together they give a complete, honest toolkit for the constant-coefficient forced linear equation — with the standing reminder that the same structure exists for variable coefficients and harder forcings, even when the integrals it leaves behind cannot be evaluated in closed form.