Introduction to Cobweb Diagrams

This worksheet is intended to help you understand where cobweb diagrams come from and how they are interpreted.

restart;

Consider the iteration map given by the following function:

f := x -> 100-0.7*(x-100);

Let's create a sequence of 50 iterates. Note the use of the colon (:) to avoid printing all 50 calculation results.

N := 50; p[0] := 10; for t from 1 to N do p[t] := f(p[t-1]); end do:

First, let's just look at the data as a time sequence.

with (plots): listplot( [ seq([t,p[t]], t=0..N) ], style=POINT);

Next, let's consider the single-lag plot, comparing sequential generations.

listplot( [ seq([p[t-1],p[t]], t=1..N) ], style=POINT, labels=["p[t]","p[t+1] "], labeldirections=[HORIZONTAL, VERTICAL]);

These data points obviously fall on a line. What line is it?

Remember how p[t+1] is defined by the iteration. That is, p[t+1] = f(p[t]). That is, the ordered pair (p[t],p[t+1]) is the same as the ordered pair (p[t], f(p[t]), which is just one point on the graph of f(x).

Let's plot f(x). We use the Maple command plot.

plot(f(x), x=0..200, y=0..200);

Of course, this is also a line. But is it the same line? We can tell Maple to join to plots if we define objects for each of the plots:

dataPlot := listplot( [ seq([p[t-1],p[t]], t=1..N) ], style=POINT); fcnPlot := plot(f(x), x=0..200, y=0..200);

Okay, that doesn't look like a plot. Whenever you define an object to contain information about a plot, it no longer appears as a plot but shows you how Maple is describing the plot. We hide the output by changing the semicolon to a colon:

dataPlot := listplot( [ seq([p[t-1],p[t]], t=1..N) ], style=POINT): fcnPlot := plot(f(x), x=0..200, y=0..200):

Once the plot objects are defined, we display them using the plots[displayplot] command.

display([dataPlot,fcnPlot], labels=["p[t]","p[t+1]=f(p[t]) "], labeldirections=[HORIZONTAL,VERTICAL]);

Great!

We can now clearly see that the sequential generation data points are clearly on the graph of f(x).

Challenge question: If you change the lag to 2 generations, the data will belong to the graph of which function?

Okay. Now we turn to the idea of cobweb diagrams. A cobweb diagram is a graphical approach to generating the time sequence that is motivated by our earlier observation that sequential generation data appears on the graph of the iteration function f(x).

Before we actually talk about the cobweb diagram, let's keep thinking about the graph and the order in which the points appear.

So, we start with the graph of the function:

display(fcnPlot);

With this plot, we use our initial condition, and plot the vertical line x=p[0]. The point of intersection of the graph of f(x) and the vertical line is the point (p[0], f(p[0])).

vertLine[0] := listplot([ [p[0],0], [p[0],200] ], style=LINE): intersectPt[0] := listplot( [ [p[0],f(p[0])] ], style=POINT): display([fcnPlot, vertLine[0], intersectPt[0]]);

The height of this point is the size of the population in the first generation. We can test the truth of the equation with the evalb (evaluate a boolean) command.

evalb(p[1] = f(p[0]));

We can do the same thing with the next time point.

vertLine[1] := listplot([ [p[1],0], [p[1],200] ], style=LINE): intersectPt[1] := listplot( [ [p[1],f(p[1])] ], style=POINT): display([fcnPlot, vertLine[0], intersectPt[0], vertLine[1], intersectPt[1]]);

Notice that the height of the first point is the same as the position of the second line. Let's repeat this one more time. Let's plot the vertical line at x=p[2].

vertLine[2] := listplot([ [p[2],0], [p[2],200] ], style=LINE): intersectPt[2] := listplot( [ [p[2],f(p[2])] ], style=POINT): display([fcnPlot, vertLine[0], intersectPt[0], vertLine[1], intersectPt[1], vertLine[2], intersectPt[2]]);

Now, you should be able to predict on your own where the next point will appear. Make your prediction before you try the next command.

vertLine[3] := listplot([ [p[3],0], [p[3],200] ], style=LINE): intersectPt[3] := listplot( [ [p[3],f(p[3])] ], style=POINT): display([fcnPlot, vertLine[0], intersectPt[0], vertLine[1], intersectPt[1], vertLine[2], intersectPt[2], vertLine[3], intersectPt[3]]);

How did you do?

Okay, now, let's go back to the first two lines.

display([fcnPlot, vertLine[0], intersectPt[0], vertLine[1], intersectPt[1]]);

I'm going to add a horizontal line connecting the first line that goes over to the second line.

horizLine[0] := listplot( [ [p[0],f(p[0])], [p[1], f(p[0])] ], style=LINE): display([fcnPlot, vertLine[0], intersectPt[0], horizLine[0], vertLine[1], intersectPt[1]]);

Well, the question is now, if I didn't already know where the second line was, how would I know how far over to draw the line?

Let's think... The first line is at the position x=p[0], and the second line is at the position x=p[1]. The height of the horizontal line is at y=f(p[0]). But this is the same as y=p[1] since p[1]=f(p[0]). That is, the horizontal line ends when it reaches the point (p[1],p[1]).

What if we continue? Let's include the third vertical line again.

horizLine[1] := listplot( [ [p[1],f(p[1])], [p[2], f(p[1])] ], style=LINE): display([fcnPlot, vertLine[0], intersectPt[0], horizLine[0], vertLine[1], intersectPt[1], horizLine[1], vertLine[2], intersectPt[2]]);

The second horizontal line starts at (p[1], f(p[1])) and joins the point (p[2], f(p[1])). What is this end point? By the same reasons as above, it is the point (p[2],p[2]). In fact, if we continued this process, drawing a horizontal line between consecutive vertical lines, then it will end when it intersects the line y=x.

identityPlot := plot(x, x=0..200,y=0..200, color=blue): display([fcnPlot, identityPlot, vertLine[0], intersectPt[0], horizLine[0], vertLine[1], intersectPt[1], horizLine[1], vertLine[2], intersectPt[2]]);

Let's do this again. Based on the pattern we've seen, what is the next value for the population?

horizLine[2] := listplot( [ [p[2],f(p[2])], [p[3], f(p[2])] ], style=LINE): display([fcnPlot, identityPlot, vertLine[0], intersectPt[0], horizLine[0], vertLine[1], intersectPt[1], horizLine[1], vertLine[2], intersectPt[2], horizLine[2], vertLine[3], intersectPt[3]]);

Looking at this graph, the vertical lines clutter our diagram, so we only draw the parts that contribute to finding the next point.

We finally reach a true cobweb diagram.

vertLine[0] := listplot( [ [p[0],0], [p[0],f(p[0])] ], style=LINE ): for t from 1 to N do horizLine[t] := listplot( [ [p[t-1],p[t]], [p[t],p[t]] ], style=LINE); vertLine[t] := listplot( [ [p[t],p[t]], [p[t], f(p[t])] ], style=LINE); end do: display([ dataPlot, fcnPlot, identityPlot, seq( vertLine[t], t=0..N ), seq( horizLine[t], t=1..N) ]);

A cobweb diagram: (1) Start with a graph of the function y=f(x). Also draw the graph of the identity function, y=x. (2) Take an initial condition, and find the corresponding x-position.

(3) Move vertically to the graph of f(x). The height is the next population size.

(4) Move horizontally to the graph of y=x. The new x-position is the new population size

(5) Treat this x-value as a new initial condition and repeat step (3) and (4).

With Maple, we can actually get this to animate so that we can visualize it a little better. First we define a function that draws the cobweb diagram through a certain number of iterations:

cobweb := n -> display([ dataPlot, fcnPlot, identityPlot, seq( vertLine[t], t=0..ceil(n) ), seq( horizLine[t], t=1..ceil(n) )]);

Now try a few of these:

cobweb(1);

cobweb(2);

cobweb(3);

Now we'll use the plots[animate] routine to make a movie.

animate(cobweb, [n], n=0..12, frames=13);