So we've seen two examples of the butterfly effect

or sensitive dependence on initial conditions.

The first example was the logistic equation with r equals 4

and the second example was the Lorenz equations, a differential equation.

So, now let me define Sensitive Dependence on Initial Conditions (SDIC)

little more carefully and then I’ll be in a position

to define chaos more carefully.

Ok, so the idea behind sensitive dependence on intial conditions is this

we say, a dynamical system has sensitive dependence on initial conditions

if very small differences in initial conditions,

so we got two small orbits that start off very close together,

that after a little while the difference between those initial conditions become large.

And we saw that perhaps most clearly for the logistic equation

where actually was plotting the difference between those two orbits.

So there is a more formal definition and I don’t want to get bogged down in it too much.

But on the other hand, some of you might like to see this formalism.

And the notion of the butterfly effect is perhaps this central thing, or one of the central things,

and maybe the most popularized idea from chaos.

so it’s worth and I think seeing what the formal definition looks like.

Ok, so here is the formal definition, I’ll state this and then try to translate this

into something a little bit more understandable.

Ok, so we have a function f, or more generally dynamical system

and let x-naught and y-naught be two possible seeds, two different initial conditions.

And so we would say that this dynamical system or function

has sensitive dependence on initial conditions if the following conditions are met.

There needs to be some number delta such that

for any initial condition x-naught there is some other initial condition

y-naught, that's within epsilon of delta, it's not,excuse me, that's within epsilon of x-naught.

It's not more than epsilon away from this first initial condition.

Moreover, this initial condition y-naught has a property that

there is some number n so that after n iterates the orbit of y-naught is more

than delta away from the orbit of x-naught.

So in other words, xn the nth iterate of x minus

yn the nth iterate of y is greater than this number delta.

Ok, so this is certainly abstract and

I think the best way to illustrate this is to imagine a game of sorts.

So, here is how to think how I imagined thinking about this game.

So, you’re going to give me a puzzle and you get to choose the following

so you get to choose an initial condition x-naught

And let’s say, you just choose whatever initial condition you want

Let's think about the logistic equation, so it has to be a number between 0 and 1.

So let's say you choose 0.7

Ok, then you get to choose some error threshold, that’s delta.

So this is a lower case Greek delta and again this has to be between 0 and 1.

let’s say you choose 0.2

and then the last thing you get to choose is the initial error epsilon,

and let's say you choose 0.1

Ok, so you make these choices of these three numbers for the logistic equation,

and then the puzzle is I have to come up with the following

so the puzzle the task for me is can I find a y-naught

some other initial condition that is within 0.1 of 0.7

that's within epsilon of the x-naught you chose.

And this y-naught that I find has to have the following property

there is some n number of iterates such that after that

or add that iterate the nth iterate of xn is now more than 0.2 away from the nth iterate of yn

So, the puzzle for me is I need to find a y-naught that has this property.

Can I do it? I am pretty sure I can.

I’ll use the program that we were using earlier on the web

to see if I can find a y-naught that meets this criteria.

Ok, so I am looking for a y-naught that's within 0.1 of 0.7

So let's see, so I should have mentioned that this is for the logistic equation with r equals 4.0

since we’re looking at the aperiodic chaotic case.

and so for x-naught I choose 0.7

well, I mean I type that in, but you chose that for me in this task you are given me.

and I need to choose some other initial condition that's close to 0.7

how close, it can’t be more than epsilon away, the epsilon you gave me is 0.1

I’ll try 0.72 that meets the criteria.

and then I am going to make the time series plots.

and now here we have in green and in purple the two orbits.

The orbits of x-naught equals 0.7

and the orbit of the seed y-naught equals 0.72.

And now I want to see if I can find some n such that

the orbits at that n are more than 0.2 apart.

so let’s see, well, we can see right here by the time

we get to 5 the difference between the two,

or the absolute value of the difference between the two looks to be about is 0.6.

and if I go down further and I look in the table of numbers here on the right

I can see indeed that by the fifth iterate the difference between

or the absolute value of the difference between

the two orbits is greater than the delta you gave me 0.2

so yes I can find the y-naught within 0.1 of the initial condition 0.7

such that after some amount of iterates it's more that

the difference between the two orbits is greater than 0.2

so the answer to this question is yes

and in particular I can find that y-naught is 0.72 then

so if y-naught, if I choose a y-naught of 0.72

then I iterated my y-naught and my x-naught,

they started off with an epsilon of each other

and then after 5 iterates the difference between these two the absolute value

is about 0.63 and 0.63 is the key thing is that this should say

this is the larger than delta.

so you said I had to make it larger than 0.2

no problem in fact I got it a lot larger than 0.2

Ok, so this is just one particular case,

one particular choice of x-naught, delta, and epsilon

so if a function has sensitive dependence on initial conditions,

I have to be able to answer this question with yes,

for whatever you choose for these three things.

Again as long as you don’t do something crazy like choose a delta greater than 1

So for talking about the logistics equation everything has to be between 0 and 1.

So as long as you choose a reasonable, and not crazy numbers here

for any reasonable choice of these three numbers

I can always answer this question yes.

So what this means is that any initial condition you choose

and you can choose a really big error threshold 0.9 0.99

if you want it and you could choose a really small epsilon

I can make even draw this so, here’s the initial condition x-naught

and you choose that and then there’s going to be some little thing

this will be x-naught plus epsilon x-naught minus epsilon

so, somewhere in here I can find an initial condition y-naught

such that after some amount of iterates

these two points are arbitrarly far apart any delta you choose

so if a function has some has sensitive dependence on initial conditions

any initial condition very close to that initial condition

is another initial condition which eventually gets very far away

so that’s the formal definition for sensitive dependence on initial conditions

here’s that long wordy thing

it’s an awful run-on sentence but I didn’t really know another way to write it.

This is a standard definition you can find it

I’m sure on wikipedia, or in any text if you want it

and it’s quite general we need to have a f just needs to be a function

that map's space to itself the space needs to be a metric space

because we have to have some notion of distance

but that’s really the only requirement for being able to use this definition.

so it applies to a whole lot of dynamical systems not just iterated functions.