Earthquakes arrive. Neurons fire. Traders submit orders. Servers log requests. In each case, what we observe is not a continuous signal but a sequence of discrete events scattered across time. The mathematical framework designed precisely for this situation is the point process.
A point process is a random collection of points on the real line (or more generally in some space). Each point represents the time of an event. The fundamental questions are always the same: How do we characterize the randomness of these events? How do we simulate realistic sequences? How do we fit a model to observed data? How do we test whether a fitted model is adequate?
This guide answers all of these questions, starting from first principles and building up to state-of-the-art self-exciting models.
Consider a few concrete scenarios:
Seismology. A major earthquake is followed by a swarm of aftershocks. The aftershock rate decays over time following the Omori–Utsu law: λ(t) ∝ (t + c)^{-p}. The key feature is that each aftershock can itself trigger more aftershocks — a cascade of self-excitation. Standard time-series methods cannot capture this.
Neuroscience. A single neuron produces action potentials (“spikes”) at variable rates. The inter-spike interval distribution is not exponential (there is a refractory period), and the firing rate depends on both the stimulus and the history of recent spikes. Modeling spike trains requires processes richer than Poisson.
Finance. In a limit order book, buy and sell orders arrive in bursts. A large buy order shifts the price, triggering more buy orders. The arrival rate is simultaneously high-frequency (microseconds), bursty, and cross-excited between the bid and ask sides.
System monitoring. A web server receives requests at a rate that follows a daily cycle (low at night, high during business hours) with occasional traffic spikes from external events. Both the periodic trend and the spike dynamics need to be modeled.
In every case, a point process model captures structure that simpler approaches miss.
Given a sequence of event times t_1 < t_2 < ... < t_n on the interval [0, T], the counting process N(t) records the cumulative number of events up to time t:
N(t) = number of events in (0, t]
N(t) is a non-decreasing, integer-valued, right-continuous step function that jumps by 1 at each event time.
The key summary of a point process is its conditional intensity function λ*(t), defined as:
λ*(t) = lim_{dt→0} P(event in (t, t+dt] | history up to t) / dt
This is the instantaneous rate of events given everything that has happened before time t. The star (*) denotes conditioning on the past, written F_{t-} (the filtration just before t). The conditional intensity completely characterizes the process: given λ*(t) for all t, we know everything there is to know about the distribution of future events.
This book covers the following main families, in order of increasing complexity:
| Model | Key Feature | Conditional Intensity |
|---|---|---|
| Homogeneous Poisson | Constant rate, no memory | λ*(t) = λ |
| Inhomogeneous Poisson | Time-varying rate, no memory | λ*(t) = λ(t) |
| Renewal | i.i.d. inter-arrivals, local memory | Depends on time since last event |
| Hawkes | Self-exciting, events trigger more events | λ*(t) = μ + Σ φ(t − tᵢ) |
| Multivariate Hawkes | Cross-excitation between M streams | λ_i*(t) = μᵢ + ΣΣ φᵢⱼ(t − tⱼₖ) |
| Cox (doubly stochastic) | Random rate process | λ*(t) = Λ(t) where Λ is random |
| Marked | Events carry additional attributes | λ*(t, m) = λ_g*(t) · p(m | history) |
Each model is a special case of or extension of the ones above it.
After working through this guide, you will be able to:
The main libraries used in this book:
| Library | Role |
|---|---|
numpy |
Array operations, random sampling |
scipy.stats |
Distributions, KS test, chi-squared |
scipy.optimize |
MLE via L-BFGS-B |
matplotlib |
Visualization: event plots, intensity curves, QQ plots |
statsmodels |
ACF computation, Ljung-Box test |
sklearn.gaussian_process |
GP kernels for Cox process simulation |
The optional tick library (by Inria) provides highly optimized Hawkes process implementations useful for validation.
Install the core dependencies:
pip install numpy scipy matplotlib statsmodels scikit-learn
If you are new to point processes, read sequentially: chapters 1–4 build the vocabulary, chapters 5–10 cover the main models, and chapters 11–14 cover inference and applications.
If you already know Poisson processes, you can start at chapter 5 (Renewal) or chapter 6 (Hawkes) and refer back as needed.
If you are primarily interested in a specific application, jump to chapter 14 (Case Studies) and follow the references back to the relevant theory.
Every chapter includes:
code/ for the full implementation| Table of Contents | Chapter 1: Mathematical Foundations → |