Simulating ΔW = √Δt Z

A computer generates a Brownian increment by scaling a standard normal random number by the square root of the time-step length.

Start with a standard normal number

\[Z\sim N(0,1).\]

\(Z\) is dimensionless, has mean 0 and variance 1. Python generates a fresh independent value with rng.normal(0, 1).

Scale it to the required time interval

\[\Delta W=\sqrt{\Delta t}Z.\]

Multiplication by \(\sqrt{\Delta t}\) keeps the mean at 0 and changes the variance correctly:

\[\operatorname{Var}(\Delta W)=(\sqrt{\Delta t})^2\operatorname{Var}(Z)=\Delta t.\]

Using \(\Delta t Z\) would give variance \((\Delta t)^2\), which is the wrong scaling.

A numerical example

If \(\Delta t=0.04\) and the generated value is \(Z=-1.2\), then \(\Delta W=\sqrt{0.04}(-1.2)=0.2(-1.2)=-0.24\). A negative increment is normal and represents downward random fluctuation over that interval.

Interactive Python laboratory

Generate increments for three time steps and verify that their empirical variance follows \(\Delta t\) while their standard deviation follows \(\sqrt{\Delta t}\).

Interactive PythonSimulating Brownian increments

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

time_steps = np.array([0.01, 0.04, 0.16])
sample_size = 100000
seed = 27
rng = np.random.default_rng(seed)

rows = []
samples = {}

for dt in time_steps:
    Z = rng.normal(0, 1, size=sample_size)
    dW = np.sqrt(dt) * Z
    samples[dt] = dW

rows.append({
        "dt": dt,
        "theoretical mean": 0,
        "sample mean": dW.mean(),
        "theoretical variance": dt,
        "sample variance": dW.var(ddof=1),
        "theoretical SD": np.sqrt(dt),
        "sample SD": dW.std(ddof=1)
    })

results = pd.DataFrame(rows)
print(results.round(5).to_string(index=False))

plt.figure(figsize=(9, 5))
for dt in time_steps:
    plt.hist(
        samples[dt], bins=70, density=True,
        histtype="step", linewidth=1.6,
        label=f"dt = {dt}"
    )

plt.xlabel("Brownian increment, ΔW")
plt.ylabel("Density")
plt.title("Larger time intervals produce wider increments")
plt.legend()
plt.grid(alpha=0.25)
plt.tight_layout()

plt.figure(figsize=(7.5, 5))
plt.plot(
    np.sqrt(time_steps),
    results["sample SD"],
    "o-", color="#b42318",
    label="Simulated SD"
)
plt.plot(
    np.sqrt(time_steps),
    np.sqrt(time_steps),
    "--", color="#174c34",
    label="Theoretical SD = √dt"
)
plt.xlabel("√dt")
plt.ylabel("Standard deviation of ΔW")
plt.title("Brownian increment scale follows √dt")
plt.legend()
plt.grid(alpha=0.25)
plt.tight_layout()

Output

Run the code to see the result.

Understand the code

Code	Meaning
`rng.normal(0, 1, size=n)`	Generates \(n\) independent standard normal values.
`np.sqrt(dt) * Z`	Converts standard normals into Brownian increments for the chosen interval.
`ddof=1`	Uses the usual sample variance and sample standard deviation.

Essential conditions

\(\Delta t\) must be positive.
Use a new independent \(Z\) for each non-overlapping time interval and each independent path.
Use the same increments only when intentionally comparing numerical solutions driven by the same Brownian path.
A random seed supports reproducibility; it does not remove randomness from the model.

What this lesson adds

You can now generate Brownian increments in Python, derive their mean and variance, explain the square-root scaling, and verify the formula numerically. The next lesson inserts these increments into Euler–Maruyama updates.