Differential equations are special because they don’t tell us the value of a variable straight up. Instead, they tell us by how much the variable will change with respect to the change of another variable. Usually that other variable is time. To numerically solve a system of differential equations we need to track the systems change over time starting at an initial state. This process is called numerical integration and there is a SciPy function for it called `odeint`

. We will learn how to use this package by simulating the ‘hello world’ of differential equations: the Lorenz system.

Here is the first part of the code where we define the function that describes the dynamics of the system.

```
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint
from mpl_toolkits.mplot3d import Axes3D
def lorenz(state, t, sigma, beta, rho):
x, y, z = state
dx = sigma * (y - x)
dy = x * (rho - z) - y
dz = x * y - beta * z
return [dx, dy, dz]
```

We start with some imports. Of course we need NumPy and `odeint`

is imported from `scipy.integrat`

. Matplotlib will be used to plot the result of our simulation. After that we define the system of differential equations that defines our Lorenz system. It consists of three differential equations that we fit into one function called `lorenz`

. This function needs a specific call signature (`lorenz(state, t, sigma, beta, rho)`

) because we will later pass it to `odeint`

which expects specific parameters in specific places. Most importantly, the first parameter must be the state of the system.The state of the Lorenz system is defined by three variables: `x, y, z`

. Our `state`

object has to be a sequence with an order that reflects this.

Inside the `lorenz`

function, the first thing we do is to unpack the state into the three state variables. This is followed by the three differential equations that described the dynamic changes of the state variables. The fact that the variable `t`

does not show up in any of these equations is a common point of confusion. The amount of change certainly depends on the amount of time. So why can we ignore `t`

here? The answer is that our numerical integrator will keep track of `t`

for us. For this particular system we could actually build a function that does not take the parameter `t`

but I include it because it can be useful if you want to add discontinuities that depend on `t`

.

While `t`

does not appear in the equations, `sigma, beta`

& `rho`

do. They are the parameters of the system and the system’s properties depend on them. We will set those parameters next.

```
sigma = 10.0
beta = 8.0 / 3.0
rho = 28.0
p = (sigma, beta, rho)
```

These are the parameters Lorenz himself used and they are known to produce the type of dynamic that the Lorenz system is most known for: the Lorenz attractor. It is important that we store these parameters in a tuple in this exact order because of our functions structure. It must be a tuple rather than another type of collection because `odeint`

expects it. Now that our parameters are defined, we will move on to define the initial values of the system. This is a critical part of solving differential equations. These equations tell us by how much the system state changes but they cannot tell us where to start.

```
y0 = [1.0, 1.0, 1.0]
```

Our system will start with all variables at 1.0. Now we can solve the system and plot the result.

```
t = np.arange(0.0, 40.0, 0.01)
result = odeint(lorenz, y0, t, p)
fig = plt.figure()
ax = fig.gca(projection="3d")
ax.plot(result[:, 0], result[:, 1], result[:, 2])
```

We solve the system with a simple call to to `odeint`

and we pass it the function that defines out system, the initial state, the time points `t`

for which we want to solve the system and the parameters `p`

. `result`

is a two-dimensional array where the rows are the time points and the columns are the state variables at that those time points. And this is how we can solve differential equations with SciPy.