Bachelier (1900): Theory of Speculation

ASR-Compatible Reproducible Python Package for the Origins of Quantitative Finance

Alpha Stochastic Research
Independent Quantitative Finance Research Laboratory

This repository provides a modern, reproducible reconstruction of Louis Bachelier's 1900 doctoral thesis:

Théorie de la Spéculation

Bachelier's work is one of the earliest mathematical foundations of modern quantitative finance. It introduced a probabilistic framework for modelling price fluctuations using what is now recognized as arithmetic Brownian motion.

This project is both:

1. a reproducible research repository; and
2. an installable Python package.

It is compatible with the Alpha Stochastic Research open-science ecosystem through the shared ASR namespace:

from asr.models import bachelier

The distribution name is:

pip install asr-theory-of-speculation

The ASR ecosystem meta-package is:

pip install asr-open-sc

At this stage, asr-open-sc acts as the lightweight ecosystem registry. The Bachelier module is provided by this repository through the asr-theory-of-speculation distribution.

The repository includes:

• arithmetic Brownian motion simulations;
• numerical verification of martingale and variance-scaling properties;
• Bachelier European call option pricing;
• Monte Carlo validation;
• comparison with Black-Scholes under low relative volatility;
• reusable Python package API;
• reproducible figure-generation scripts;
• automated tests;
• interactive Jupyter notebook;
• LaTeX working paper source;
• citation metadata;
• open-source documentation.

This repository exposes the Bachelier model under the shared Alpha Stochastic Research namespace:

from asr.models import bachelier

The installation package is:

pip install asr-theory-of-speculation

The import path is:

asr.models.bachelier

Example:

from asr.models import bachelier

time_grid, paths = bachelier.simulate_paths(
    initial_price=100.0,
    volatility=2.0,
    maturity=1.0,
    n_steps=250,
    n_paths=5_000,
    seed=42,
)

analysis = bachelier.analyze_paths(
    time_grid=time_grid,
    paths=paths,
    initial_price=100.0,
    volatility=2.0,
)

price = bachelier.call_price(
    initial_price=100.0,
    strike=100.0,
    volatility=2.0,
    maturity=1.0,
)

print(analysis.terminal_mean)
print(price)

This package is part of the broader ASR open-science Python ecosystem:

asr.open_sc
asr.models.bachelier
asr.risk.tail
asr.portfolio.optimization
asr.ml.deep_hedging
asr.agents.trading

The ecosystem meta-package is maintained separately in:

https://github.com/Alpha-Stochastic-Research/asr-open-sc

The objective of this project is to connect historical financial mathematics with modern reproducible research.

This repository aims to:

• preserve one of the foundational works of quantitative finance;
• provide readable Python implementations;
• expose a reusable package interface;
• make the numerical results reproducible;
• explain the mathematical structure behind Bachelier's model;
• support students, researchers, and practitioners interested in financial mathematics;
• provide a transparent open-science research package.

Bachelier models the price process as an arithmetic Brownian motion:

where:

• P_t is the price at time t;
• P_0 is the initial price;
• σ is the arithmetic volatility;
• W_t is a standard Brownian motion.

This implies:

and

The model is simple, elegant, and historically important. It also has a structural limitation: because prices are normally distributed, negative prices are theoretically possible.

Under the Bachelier model, the terminal price is:

where:

For a European call option with strike K, the Bachelier price is:

with:

where:

• Φ is the standard normal cumulative distribution function;
• φ is the standard normal probability density function.

For an at-the-money call, where K = P_0, the formula simplifies to:

This illustrates the square-root-of-time scaling of option values in the Bachelier framework.

asr-theory-of-speculation
├── .github/
│   └── workflows/
│       └── python-ci.yml
├── assets/
│   └── logo.png
├── figures/
│   ├── fig1_random_walk_martingale.png
│   └── fig2_option_pricing.png
├── notebooks/
│   └── bachelier_theory_of_speculation_reproduction.ipynb
├── paper/
│   ├── main.tex
│   ├── references.bib
│   └── README.md
├── src/
│   ├── brownian_motion.py
│   ├── option_pricing.py
│   └── asr/
│       └── models/
│           └── bachelier/
│               ├── __init__.py
│               ├── pricing.py
│               ├── process.py
│               └── simulation.py
├── tests/
│   ├── conftest.py
│   ├── test_brownian_motion.py
│   ├── test_option_pricing.py
│   └── test_package_imports.py
├── AUTHORS.md
├── CHANGELOG.md
├── CITATION.cff
├── LICENSE
├── README.md
├── REPRODUCIBILITY.md
├── pyproject.toml
└── requirements.txt

Clone the repository:

git clone https://github.com/Alpha-Stochastic-Research/asr-theory-of-speculation.git
cd asr-theory-of-speculation

Create a virtual environment:

python -m venv .venv

Activate it on macOS or Linux:

source .venv/bin/activate

Activate it on Windows:

.venv\Scripts\activate

Upgrade pip:

python -m pip install --upgrade pip

Install the project as an editable package with development dependencies:

pip install -e ".[dev]"

Alternative simple dependency installation:

pip install -r requirements.txt

After installation, verify the ASR import:

python - <<'PY'
from asr.models import bachelier

print("ASR Bachelier version:", bachelier.__version__)

price = bachelier.call_price(
    initial_price=100.0,
    strike=100.0,
    volatility=2.0,
    maturity=1.0,
)

print("Bachelier ATM call price:", price)
PY

Once published on PyPI, the package can be installed with:

pip install asr-theory-of-speculation

Then imported with:

from asr.models import bachelier

The ASR ecosystem registry package can be installed separately with:

pip install asr-open-sc

Then used with:

import asr.open_sc as asr_sc

asr_sc.print_ecosystem()

The reproduction scripts can be run directly from the repository root:

python src/brownian_motion.py
python src/option_pricing.py

For direct Python usage without installing the package, add src/ to PYTHONPATH.

On macOS or Linux:

PYTHONPATH=src python -c "from asr.models import bachelier; print(bachelier.call_price(100, 100, 2, 1))"

On Windows PowerShell:

$env:PYTHONPATH="src"
python -c "from asr.models import bachelier; print(bachelier.call_price(100, 100, 2, 1))"

For a clean and persistent research environment, the editable installation method remains preferred:

pip install -e ".[dev]"

Compute a Bachelier call option price:

from asr.models import bachelier

price = bachelier.call_price(
    initial_price=100.0,
    strike=100.0,
    volatility=2.0,
    maturity=1.0,
)

print(price)

Simulate Bachelier paths:

from asr.models import bachelier

time_grid, paths = bachelier.simulate_paths(
    initial_price=100.0,
    volatility=2.0,
    maturity=1.0,
    n_steps=250,
    n_paths=5_000,
    seed=42,
)

analysis = bachelier.analyze_paths(
    time_grid=time_grid,
    paths=paths,
    initial_price=100.0,
    volatility=2.0,
)

print(analysis.terminal_mean)
print(analysis.terminal_empirical_variance)
print(analysis.terminal_theoretical_variance)

Run the high-level experiments:

from asr.models import bachelier

time_grid, paths, analysis = bachelier.run_brownian_motion_experiment()

results = bachelier.run_option_pricing_experiment()

print(results)

Run the arithmetic Brownian motion experiment:

python src/brownian_motion.py

Run the option pricing experiment:

python src/option_pricing.py

Generated figures are saved in:

figures/

An interactive Jupyter notebook is available in:

notebooks/bachelier_theory_of_speculation_reproduction.ipynb

The notebook reproduces the main numerical experiments:

• Bachelier arithmetic Brownian motion;
• martingale and variance-scaling checks;
• Bachelier European call pricing;
• Monte Carlo validation;
• at-the-money square-root-of-time scaling;
• local comparison with Black-Scholes.

To run it:

jupyter notebook notebooks/bachelier_theory_of_speculation_reproduction.ipynb

The notebook is intended as an educational and exploratory companion. The tested, reusable implementation remains in the package under:

src/asr/models/bachelier/

Run the full test suite with:

pytest -q

The tests check:

• package import interface;
• simulation dimensions;
• reproducibility under fixed random seeds;
• martingale behaviour;
• theoretical variance scaling;
• Bachelier option pricing formula;
• Monte Carlo validation;
• Black-Scholes benchmark behaviour;
• invalid input handling;
• high-level experiment functions.

This repository uses GitHub Actions to validate the project automatically.

The CI workflow checks that:

• the package installs with pip install -e ".[dev]";
• the public import works with from asr.models import bachelier;
• the test suite passes;
• the Brownian motion script runs successfully;
• the option pricing script runs successfully;
• expected figures are generated.

Workflow file:

.github/workflows/python-ci.yml

The project generates two main figures:

The figures are generated by:

python src/brownian_motion.py
python src/option_pricing.py

The LaTeX source of the accompanying working paper is available in:

paper/main.tex

The paper provides a scientific reconstruction of Bachelier's theory with:

• literature review;
• historical source and scope of reproduction;
• mathematical derivations;
• computational methodology;
• numerical results;
• discussion and limitations;
• reproducibility statement;
• code and data availability;
• references and appendices.

To compile the paper from the paper/ directory:

pdflatex main.tex
bibtex main
pdflatex main.tex
pdflatex main.tex

This repository is designed to work as one module within the Alpha Stochastic Research open-science Python ecosystem.

The shared namespace strategy is:

asr
├── open_sc
├── models
│   └── bachelier
├── risk
│   └── tail
├── portfolio
│   ├── optimization
│   └── hrp
├── ml
│   └── deep_hedging
└── agents
    └── trading

This repository provides:

from asr.models import bachelier

The ecosystem registry is provided by:

pip install asr-open-sc

and can be used with:

import asr.open_sc as asr_sc

asr_sc.print_ecosystem()

The ASR ecosystem is modular. Each research repository remains independently installable while sharing the same Python namespace.

This project is designed as a reproducible research repository.

Reproducibility principles:

• installable Python package;
• public import interface;
• shared ASR namespace compatibility;
• fixed random seeds;
• explicit dependencies;
• clean source code;
• documented numerical experiments;
• automated tests;
• generated figures saved from scripts;
• notebook-based interactive reproduction;
• citation metadata included.

For full details, see:

REPRODUCIBILITY.md

If you use this repository in your research, teaching, or open-source work, please cite it using the metadata provided in:

CITATION.cff

Suggested citation:

Alpha Kabinet TOURE and Alpha Stochastic Research.
Bachelier (1900): Theory of Speculation — ASR-Compatible Reproducible Python Package.
Alpha Stochastic Research, 2026.
https://github.com/Alpha-Stochastic-Research/asr-theory-of-speculation

This repository is released under the MIT License.

You are free to use, modify, and distribute the code under the terms of the license.

See:

LICENSE

Primary author:

Alpha Kabinet TOURE
Founder and CEO, Alpha Stochastic Research

Institution:

Alpha Stochastic Research
Independent Quantitative Finance Research Laboratory

For details, see:

AUTHORS.md

Bachelier, L. (1900).
Théorie de la Spéculation.
Annales Scientifiques de l'École Normale Supérieure, 17, 21–86.

Samuelson, P. A. (1965).
Rational Theory of Warrant Pricing.
Industrial Management Review, 6(2), 13–31.

Black, F. and Scholes, M. (1973).
The Pricing of Options and Corporate Liabilities.
Journal of Political Economy, 81(3), 637–654.

Merton, R. C. (1973).
Theory of Rational Option Pricing.
The Bell Journal of Economics and Management Science, 4(1), 141–183.

Alpha Stochastic Research (ASR) is an independent quantitative finance research laboratory dedicated to rigorous, transparent, and reproducible research.

ASR works at the intersection of:

• quantitative finance;
• financial mathematics;
• stochastic modelling;
• risk management;
• portfolio optimization;
• scientific computing;
• financial machine learning;
• open science;
• reproducible research.

Website:

https://asr-lab.online

GitHub organization:

https://github.com/Alpha-Stochastic-Research

Research contact:

research@asr-lab.online