Awesome Open Source
Awesome Open Source

# Dynamical Systems and Chaos

This software has been developed as part of the (optional) homeworks of the MOOC Introduction to Dynamical Systems and Chaos (Summer, 2016), leaded by David Feldman, Professor of Physics and Mathematics at College of the Atlantic.

For more details about the chaos and sync theories, see the Steven Strogatz's books Sync and Nonlinear Dynamics and Chaos. Or the David Feldman's introductory book Chaos and Fractals: An Elementary Introduction.

## Some theory

### Logistic maps

We start by considering a very simple model of a population where there is some limit to growth:

f(x) = rx(1-x)

r is a growth parameter, x is measured as a fraction of the annihilation parameter (the variable x is thus always between 0 and 1), and f(x) gives the population next year given x, the population this year.

By iterating this function we can create a dynamical system, that is, a system that evolves in time according to a well-defined, unchanging rule. The number we start with is called the seed or initial condition. The resulting sequence of numbers

x0 x1 = f(x0) ... xn = f(xn-1)

is called the itinerary or orbit (or sometimes a time series or a trajectory).

## Software

The software is written in Python and compatible with both Python 2 and 3 (tested on Fedora 24 through Fedora 30 Workstation), but if you want to run it under Python 2, you need to modify the shebang line of each Python script.

legraph.py -- Plot Logistic, Cube, and Sine orbits
Iterate a logistic, cube, or sine equation for different r and x0 values and make time series plots;
finalstate.py -- Plot Final State Diagrams
Iterate a logistic, cube, or sine equation for different r and x0 values and plot the final state diagram;
bifurcation.py -- Plot Bifurcations Diagrams
Plot the bifurcation diagram of a cubic, logistic (default), or sine maps;
lelib.py -- Object-oriented core library for computing and plotting
A simple object-oriented Python library for computing time series and plotting orbits, final state and bifurcations diagrams.

The core library requires the (widely-available and very popular) Python libraries `NumPy` and `matplotlib`.

### Working With Python3.3+ Virtual Environments

When testing `dynamic-systems-and-chaos` it's easier to use a virtual environment. Python 3 presents a few steps to ensure you are actually installing and working with files inside of your virtual environment. Refer to the original Python documentation Installing Packages Using pip and virtualenv for the official instructions on this topic.

#### `dynamic-systems-and-chaos` virtual Environment Example

Create a virtual environment named `.venv` inside the git repository root:

``````\$ git clone https://github.com/madrisan/dynamic-systems-and-chaos.git
\$ cd dynamic-systems-and-chaos
\$ python3 -m venv .venv
``````

Now that a virtualenv has been created in our `.venv` folder we should activate the virtual environment.

``````\$ source .venv/bin/activate
(.venv)\$
``````

The virtual environment contains no extra modules needed to run `dynamic-systems-and-chaos`. Therefore, we want to install the dependencies from the `requirements.txt` file. However, we want to specify that we're using the virtual environment `pip3`:

``````(.venv)\$ pip install --upgrade pip
(.venv)\$ .venv/bin/pip3 install -r requirements.txt
``````

You are now ready to start running and testing `dynamic-systems-and-chaos` with a virtual environment using Python 3.

### Available Scripts

##### legraph.py
``````(.venv)\$ python3 dynamic-systems-and-chaos/legraph.py --help
usage: legraph.py [-h] -0 X0 [-1 X1] [-d] -r R [-s S] -n N
[-m {logistic,cubic,sine}]

Plot of Logistic Equation Time Series v.4 (stable)

optional arguments:
-h, --help            show this help message and exit
-0 X0, --x0 X0        1st initial condition
-1 X1, --x1 X1        2nd initial condition (optional)
-d, --dots-only       do not connect the dots with lines (default: False)
-r R, --rate R        growth rate parameter
-s S, --skip S        skip plotting the first 's' iterations
-n N, --steps N       number of iterations
-m {logistic,cubic,sine}, --map {logistic,cubic,sine}
select the desired map (logistic, cubic, or sine)

Examples:

# time series with a stable fixed point
legraph.py -0 0.4 -r 3.2 -n 50
legraph.py -0 0.4 -1 0.45 -r 3.2 -n 50
# chaotic results (randon output)
legraph.py --x0 0.2 --x1 0.2000001 -r 4.0 -n 50
legraph.py -0 0.2 -r 3.6 -n 5000 --dots-only
legraph.py -0 0.9 -r 4.5 -n 50 --map=cubic
legraph.py -0 0.4 -r 0.8 -n 50 --map=sine
``````
##### finalstate.py
``````\$ (.venv)\$ python3 dynamic-systems-and-chaos/finalstate.py --help
usage: finalstate.py [-h] [-0 X0] -r R [-s S] [-n N]
[-m {logistic,cubic,sine}]

Plot of the Final State Diagram v.4 (stable)

optional arguments:
-h, --help            show this help message and exit
-0 X0, --x0 X0        initial condition (default: 0.5)
-r R, --rate R        growth rate parameter
-s S, --skip S        skip plotting the first 's' iterations (default: 2000)
-n N, --steps N       number of iterations (default: 1000)
-m {logistic,cubic,sine}, --map {logistic,cubic,sine}
select the desired map (logistic, cubic, or sine)

Examples:

finalstate.py -r 3.492
finalstate.py -r 3.614 -s 200 -n 300
finalstate.py -0 0.4 -r 3.2 -s 10 -n 50
finalstate.py -0 0.8 -r 6.2 -n 20 --map=cubic
``````
##### bifurcations.py
``````\$ (.venv)\$ python3 dynamic-systems-and-chaos/bifurcations.py --help
Plot the Bifurcation Diagram of Logistic, Cubic, and Sine Maps v.4 (stable)

usage: bifurcations.py [-h] [-r R] [-y Y] [-s S] [-n N]
[-m {logistic,cubic,sine}]

optional arguments:
-h, --help            show this help message and exit
-r R, --rate R        range of the growth rate parameter (default: the
entire range)
-y Y, --people Y      normalized range of the population (default: the
entire range)
-s S, --skip S        skip plotting the first 's' iterations (default: 200)
-n N, --steps N       number of iterations (default: 100)
-m {logistic,cubic,sine}, --map {logistic,cubic,sine}
select the desired map (logistic, cubic, or sine)

Examples:

bifurcations.py -r 1:4
bifurcations.py -r 4:6.5 --map=cubic
bifurcations.py --map=sine -s 200 -n 200
bifurcations.py -r 3.:4. -s 500 -n 600
bifurcations.py -r 3.5:3.6 -y .3:.6 -s 800 -n 1000
``````

## Examples

#### Dynamical System with a Periodic Orbit

The following example shows a periodic orbit with two fixed points.

In mathematics, a fixed point of a function is an element of the function's domain that is mapped to itself by the function. That is to say, c is a fixed point of the function f(x) if and only if f(c) = c

``````# initial condition: 0.4 - growth rate: 3.2 - 50 iterations starting from 0 (x0)
(.venv)\$ python3 dynamic-systems-and-chaos/legraph.py --x0 0.4 -r 3.2 -n 50
``````

#### Aperiodic Orbits and The Batterfly Effect

For r = 4 (and other values), the orbit is aperiodic: it never repeats. Applying the same function over and over again does not result in periodic behavior.

We can use `legraph.py` to compare time series for two different initial conditions.

``````(.venv)\$ python3 dynamic-systems-and-chaos/legraph.py --x0 0.2 --x1 0.2000001 -r 4.0 -n 50
``````

The bottom plot is the difference between the two time series in the top plot.

You can note that the two orbits start very close together and eventually end up far apart. This is known as sensitive dependence on initial conditions (SDIC), or the butterfly effect.

The latter name cames from the title of a 1979 paper by Ed Lorenz called "Predictability: Does the Flap of a Butterfly's Wings in Brazil Set Off a Tornado in Texas?". The idea is that in a chaotic system, small disturbances grow exponenfially fast, rendering long-term prediction impossible.

More precisely, for any initial condition x there is another initial condition very near to it that eventually ends up far away. To predict the behavior of a system with SDIC requires knowing the initial condition with impossible accuracy. Systems with SDIC are deterministic yet unpredictable in the long run.

#### Aperiodic Orbits with holes

The aperiodic orbits are always bounded but do not necessarily cover all the domain. They can present one or more holes.

``````(.venv)\$ python3 dynamic-systems-and-chaos/legraph.py --x0 0.2 -r 3.6 -n 500
``````

We can increase the number of iterations and add the command line switch `--dots-only` in order to better visualize this behaviour.

``````(.venv)\$ python3 dynamic-systems-and-chaos/legraph.py --x0 0.2 -r 3.6 -n 5000 --dots-only
``````

#### Final State Diagrams

For a given r value, the program `finalstate.py` will iterate 1000 times by default (`-s`), then plot the next 2000 iterates (`-n`) on the unit interval. The resulting plot is called a final-state diagram.

The number of skipped (`-s`) and plotted (`-n`) iterations can be manually tuned as shown in the following example.

``````(.venv)\$ python3 dynamic-systems-and-chaos/finalstate.py -r 3.614 -s 200 -n 300
``````

Here you can find an example of a final-state diagram generated by a periodic orbit.

``````(.venv)\$ python3 dynamic-systems-and-chaos/finalstate.py -r 3.2 -s 10 -n 50
``````

#### Bifurcation Diagrams

We can "glue" together the final state diagrams made for different values of the parameter r to make a bifurcation diagram, that lets us see, all at once, all the different behaviour exhibited by a dynamical system as we vary the parameter r.

##### Logistic Map

The script `bifurcations.py` lets us plot the bifurcation diagram of the logistic map (the map selected by default)

f(x) = rx(1-x)

``````(.venv)\$ python3 dynamic-systems-and-chaos/bifurcations.py -r 2:4 -n 300 -s 400
``````

##### Cubic Map

We can plot the bifurcation diagram of the cubic map

f(x) = rx2(1-x)

by adding the command-line switch `--map=cubic`

``````(.venv)\$ python3 dynamic-systems-and-chaos/bifurcations.py -r 4:6.5 --map=cubic
``````

##### Sine Map

And finally plot the bifurcation diagram of the sine map

f(x) = r sin(Ļxā2)

by using the command-line switch `--map=sine`

``````(.venv)\$ python3 dynamic-systems-and-chaos/bifurcations.py --map=sine -s 200 -n 200
``````

You can note the similarities between the three bifurcation diagrams (and all the ones generated by the class of iterated functions that map an interval to itself and have a single quadratic maximum.)

This is a well known result that came from the amazing phenomenon of the universality of the period-doubling route to chaos (also known as Feigenbaum's constant). The physicist Mitchell Feigenbaum in fact showed that there are certain universal laws governing the transition from regular to chaotic behaviour, His predictions were confirmed in experiments on electronic circuits, swirling fluids, chemical reactions, semiconductors, and heard cells. Feigenbaum's laws transcended the superficial differences between heart cells and and silicon semiconductors. Different materials, the same laws of chaos!

Get A Weekly Email With Trending Projects For These Topics
No Spam. Unsubscribe easily at any time.
python (54,564)Ā
python3 (1,645)Ā
mathematics (158)Ā
matplotlib (123)Ā
chaos (27)Ā
dynamical-systems (22)Ā
complexity (19)Ā