The principal use of convolution in modeling is for finding the effects of a series of events. For example, when you hire a new employee, you expect an increase in overall productive capacity. But that increase might be gradual — the new employee might need a period of time to learn how to do the job. The increase in productive capacity probably follows a characteristic "learning curve," which can be simple enough to describe, though it might vary from job to job. When we have a stream of hires, 35 in Q1, 25 in Q2, 10 in Q3, and so on, the cumulative effects of this learning curve can be difficult to represent in a model.

The overall effect is rather like a choral "round", of which "Row, row, row your boat" is a familiar example. When the first batch of hires is midway up the learning curve, along comes the second batch, which starts out at a low level of productivity. Then, as the first batch nears the top of the curve, the second reaches the middle, and the third batch comes along, again at a low level. Capturing this in spreadsheet cells can be difficult.

Convolution makes it easy. Convolution gives you a way to find the time response — often called the "temporal response" — of a system as it responds to a specified input, provided that you know the "base response" of the system, which is its response to a single-event input.

The net increase in productivity of new hires in the above example, as a function of time, is the convolution of the "base response" — in this case, the learning curve — with the "input" — in this case, the hiring stream. In signal theory, the base response is called the Impulse Response; in Electrodynamics, it's called the Green's Function.

Three conditions must be satisfied before we can justifiably apply convolution. A system that satisfies these three conditions is said to be non-predictive, linear, and time-invariant. Succinctly:

To compute the response of a non-predictive, linear, time-invariant system to an input described as a stream of events, each of which triggers a "base response," convolve the input with the base response.

A system is non-predictive if it cannot respond to changes in its input until the change arrives. Simple enough — most systems can't. (If you find one, take it to Las Vegas or to your broker immediately. You're wasting your time reading this!).

The second condition, linearity, is satisfied if two conditions hold. First, for a linear system, the response to the sum of two inputs is the sum of the responses to each of the inputs applied separately. Second, linearity requires that the response to an input must scale in proportion to the size of the input.

Finally, a system is said to be time-invariant if its response to a given input is the same size and shape, independent of when the input is applied. In the productivity example above, we actually don't have time-invariance, because the productivity curve for the second batch of hires can become a bit steeper than it was for the first, especially if the training organization learns how to train more effectively. When this happens, the enhanced productivity due to hiring of the second batch comes about more rapidly than did the first. Strictly speaking, time invariance is violated.

In convolution, we make the assumption that each batch of hires becomes effective in exactly the same way as all other batches. We assume that the system behaves the same way at all times. It's a pretty good assumption for planning, but it's not very good for operational applications. Modeling is only approximate.

If a system is non-predictive, linear and time-invariant, you can use convolution to compute its behavior in response to inputs.

Mathematically, we can express the convolution of two streams of data relatively simply. There are two ways to look at it. The first method is based on our understanding of what we're calculating — I call it "What We're Doing." The second method is based on a more mechanical description of how we calculate it — I call it "How We Do It." When you read the descriptions of these two calculations, they seem different, at first, and it's a bit tricky to see how they're the same, but they are, as we'll see.

For examples of absolute and relative references, see the demonstrations for Session 1.As described above, what we're doing is computing the response of a system to an input stream. We do that by adding together the responses of the system to each element of the input stream. We assume that the response of the system to a unit input at time period N is the same as the response of the system to a unit input at time period 1, except that it's delayed by N-1 time periods. This assumption is valid for all time-invariant systems. And we assume that when we scale the input by a factor of K, the response of the system scales by a factor of K. This assumption is valid for linear systems. Finally, we assume that we can add together the responses to all the various elements of the input stream, and that result is the response to the input stream. This follows again from linearity.

Let's do some examples. Suppose the response to a unit input at time period 1 is a stream described as (0, 1, 2, 3, 3, …). This is the system's base response. The three dots indicate that forever afterwards, the system's response is 3. Below is a table of example responses to example inputs for this system. The responses are given only for times 1 through 5. Some system responses obviously continue beyond T=5, but we're ignoring the parts of the responses after T=5.

In the table above, we find the response to Example 1 by just delaying the base response by one time period. The response to Example 2 is just two times the response to Example 1. The response to Example 3 is 2 times the base response. The response to Example 4 is the sum of the responses to Examples 2 and 3. In all cases, we just apply linearity and time invariance to the responses to the elements of the decomposition of the input.

Perhaps it will help to see how this works graphically. Let's suppose that the input is (1, 2, -1, 0, 2), and 0 after that. For this example, let's look at responses for T=0 to T=10. Obviously, we could work out the numerical result as in the table above, and the result is: (0, 1, 4, 6, 8, 10, 13, 15, 15, 15). To see this graphically, we will plot the response for each of the five input steps, then add them up graphically. You can see this done in the demonstration file for convolution.

Now let's try something more abstract. Let's suppose that the value of the base response at time period k is b(k), and that the value of the stimulus (or input) at time k is s(k). We also assume that both the stimulus and base response are zero for time period earlier than 1, and that the system is at rest at t = 0. What is the response r(m) of the system to s at time m?.

The only contributions to the value s(m) are from parts of s that occur from 1 to m. s(1) kicks off a response shaped like b, with no relative delay. Its value at m is just s(1)*b(m). s(2) kicks of a response shaped just like b, but delayed by 1 unit. Its value at time m is just s(2)*b(m-1). So the total is just

r(m) = s(1)*b(m) + s(2)*b(m-1) 
              + s(3)*b(m-2) + … + s(m)*b(1)

This is the value of the response r at time m.

This formula has an interesting symmetry property. If we interchange s and b, we get exactly the same result. (Try it for a specific value of m!) This means that if $ represents the "convolution product" of two streams, s$b = b$s. This is why when you use the Convolve macro, the order of its two arguments doesn't matter.

This perspective is another way to look at the formula above that gives exactly the same result. It embodies the same algorithm that the Convolve macro uses. Simply put, to convolve two streams, you take the first one, flip it around backwards, and successively slide it to the right, one unit at a time, overlaying it on the other stream, computing the products of the "lined up" values, and adding them together to get the total for that value of slide. This is exactly what the formula above does.

To use the Convolve macro, you must load it into Excel. Convolve isn't an Excel function — it's a function I wrote as an Excel Macro using Visual Basic. Consequently, standard Excel workbooks don't have it. If you see cells that contain #NAME? symbols when you use Convolve, there is a good chance that the Convolve macro isn't present. See the installation instructions.