So we can iterate the Hénon map very
similar to how we iterated the logistic

equation. We just start with a value, in
this case it's two values and we just get

the next value by applying the function
over and over again.

And we get a time series for x and a time
series for y.

It's a straightforward task, soon we'll
turn to a computer to do this for us.

So now that we have these numbers, what
can we do?

Well, as usual in this course, we'd like
to know what's the long term behavior of

the orbit? Are there fixed points? Are
they stable? Can we have chaos? What does

it look like?

So we can plot the time series for x just
like we did for the logistic equation.

And we can plot the time series for y as
well. Those will both be one dimensional

functions, i.e. a dimension for x, a
dimension for y.

But another thing we can do, is plot x
against y. Similar to how we plotted x

against y or r against f for these two
dimensional differential equations.

So for the logistic equation we had a
final state diagram that was one

dimensional. Here, we can have a diagram
that would be two dimensional.

So I'll just sketch this and then we'll
look at it on the computer.

So the first point, x=0.2, y=0.4. I might
go over 2, up 4, maybe something sort of

roughly like that. And then the next point
x=1.3, so that might be maybe out here.

And y_1 is kind of down here. Because
x=1.364, y=0.06 so there's that point.

Then the next point now x is negative,
x=-0.6 and y=0.49, that looks like, let's

see that would be probably be around here.
And let's see, this is point 0, and that

was point 1, this was point 2 and so on.
So I could keep plotting these dots, many,

many of them, and see what happens. See
if we get pulled into a fixed point or

maybe some sort of a cycle or something.

If I wanted to know just the long term
behavior, I might iterate for 10 or 100

times not plot those but then plot the
next 100 or something like that.

So this is very similar to what we did
for the final state diagram for the

logistic equation, but now instead of a
line we have a plane.

We have a plane because we have two
numbers, two coordinates, not just one.

So there's a program on the Complexity
Explorer site that will do this for us.

So let's take a look at that program now
and understand some of its features.

So here's the program on the Complexity
Explorer site that will make time series

plots of the Hénon map for us. You can
find this program on the site.

There's a link to it in the right hand
navigation bar.

I think it's section 7.6 or 7.7 that says
something like Hénon map programs.

Shouldn't be too hard to find.

So here's the program. It comes up in a
pop-up window that I've resized slightly.

It should look pretty familiar. It's very
similar to the program that we used to

plot the logistic equation,
the logistic map.

So, first we can control the number of
iterations. I'll choose the default, 40.

Our initial conditions, the ones we've
been working with; x_0=0.2 but y_0=0.4.

So I'll change that. And the parameter a,
there's two parameters now, a=0.9, b=0.3.

And I'll describe what this box does in a 
second. So let's make the plot.

So this is a time series plot for the x
values; the x values change over time.

Time 0, time 1, time 2 and so on. 
There's the time series plot.

Here's a time series plot for the y value,
it also changes over time.

And we can make time series plots for both
x and y separately just like we did for

the logistic equation.

Let me slide down here.
It also produces a list of numbers.

Here's our initial condition, (0.2, 0.4).
The first iterate was (1.364, 0.06).

That we did in the video.

For the quiz you should have calculated
these values, (-0.614, +0.4092)

and computers being what they are, just
keep doing this again and again and

produce this list of numbers.

Let's now look at this xy plot. So this is
what I was describing a moment ago in the

video. Instead of plotting x vs. time and
y vs. time, we can plot x vs y.

So we lose the time coordinate but we
can see things two dimensionally.

The first value, our initial condition was
(0.2, 0.4). So we started at x=0.2 and

y=0.4 and that's that point right there.

Then the next value in our itinerary was
x=1.364 and a y=0.06 and that's this point

here. So this was our first point and that
was our second. Our third point, the one

you calculated in the quiz was x_2=-0.614,
so that's about over here, -0.61, and the

y value was 0.409 and there it is, that's
the second iterate.

This is the initial condition, (x_0, y_0),
this is (x_1, y_1), this is (x_2, y_2).

And then we can keep going trying to track
the locations of (x_3, y_3), the fourth

iterate, the fifth iterate and so on.

So we see this dot jumps around the plane.

Often in dynamical systems we're
interested just in the long term behavior

of the system. So it kind of looks like
this is going to something periodic.

Let's test that out. Maybe I'll plot 100
iterates. Make the time series plot.

And it does indeed look like it's becoming
almost, maybe it's period 2, maybe it's

period 4. It's a little bit hard to tell.
Let's go back and look at this.

So here, this is the xy view. There is our
starting point and there is the next point

there is the next point. And we can see
that points are accumulating in here.

If we're interested in the long term
behavior I don't want to plot these first

dozen or first 20 or 30 points. I'm really
interested in just the points after the

map has been going for a while.

So that's where this box comes in.
So when making the xy plot, this will let

me skip some of the iterates. I'm going to
choose to skip the first 50 iterates.

So then what the xy plot will do, that's
the blue plot down below, is it will, the

computer will iterate the function for 50
times and it won't plot the points on the

xy plot, but it'll only start plotting
with the 51st iterate and should do the

next 50. So let's make plots.

The purple plots don't change.

But down here, you can see that our
starting point, which was (0.2, 0.4) right

around here, that that seems to be gone.
And we're starting to see that the points

are oscillating, more or less, between
these two regions.

So we can't see the oscillation on this
because we can't see time value.

But we can tell from here, that the orbits
are oscillating between a high and a low,

high and low, but they're not quite
exactly the same.

So let's see here. I'm going to now plot,
or have it do, let's have it do 10,000

iterates, I better do 5,000, I don't want
to use things too much. And I'm going to

have it skip plotting the first 4,900. 
So the purple plots, the time series

plots are always going to show all of
the iterates. So let's get this started.

So we expect that to be a big, purple
blob. We've seen those blobs before.

It's taking a little while. There it is.

So that's a time series plot of 5,000
iterates for x, there's y, but let's see

what this looks like.

So at this point, it's becoming clear that
it looks like the function is resolving,

the behavior is resolving to where it's
oscillating just between two points,

or maybe among four points, but the two
ones are almost identical.

In any event, this is clearly some sort of
a periodic behavior.

Maybe period 2, maybe period 4.

But the main thing is that the long term
behavior is simple and it's periodic.

So for the logistic map we did a final
state diagram for a periodic orbit and it

just had 2 or 4 or 8, however many points
it was, corresponding to the periodicity

of the orbit. We see the same thing here
but now the points live on a plane and not

on a line.

So we'll do a lot more with the Hénon map
in the next unit where we'll see what

chaotic behavior in two and three
dimensions looks like and we'll see

strange attractors. But for now, the main
new thing here is that we have a map that

has an x and y in it and those x and y
values get mixed up because in this case,

the x value depends on y and x. And we
can plot two time series for that and

that's pretty familiar.

Let me go back here and get a picture
that is going it to look better.

So we can plot time series like we have
before but the new thing is that we can

plot, have those orbits evolve on a two
dimensional grid, a two dimensional

plane, instead of a one dimensional one.