Chapter 2: The Homogeneous Poisson Process

The homogeneous Poisson process (HPP) is the simplest and most fundamental point process. It serves as the baseline model and the building block for every more complex process in this book. Its defining feature is complete randomness: events occur at a constant average rate with no memory of past events.

2.1 Three Equivalent Definitions

The HPP with rate λ > 0 can be defined in three equivalent ways, each illuminating a different aspect of the model.

Definition 1: Independent stationary increments.

• N(0) = 0
• N(a, b] is independent of N(0, a] for any 0 ≤ a < b (independent increments)
• N(a, b] has the same distribution as N(0, b−a] (stationary increments)
• N(a, b] ~ Poisson(λ(b−a))

Definition 2: Via inter-arrival times. The waiting times between consecutive events X_i = t_i − t_{i-1} (with t_0 = 0) are independent and identically distributed:

X_i ~ Exponential(λ)

Definition 3: Via conditional intensity. The conditional intensity is constant (no memory):

λ*(t) = λ   for all t ≥ 0

All three definitions are equivalent; the equivalence is a deep result that uniquely characterizes the HPP among all point processes.

2.2 Key Statistical Properties

Counts: For any interval of length Δ:

P(N(t, t+Δ] = k) = e^{-λΔ} (λΔ)^k / k!

E[N(t, t+Δ]] = λΔ
Var[N(t, t+Δ]] = λΔ

The mean equals the variance — this is called equidispersion and is a testable property. The Fano factor F = Var/Mean = 1 exactly for a Poisson process.

Inter-arrival times:

f(x) = λ e^{-λx},   x ≥ 0
E[X] = 1/λ,   Var[X] = 1/λ²

The memoryless property: The exponential distribution is the only continuous distribution with the memoryless property:

P(X > s + t | X > s) = P(X > t)   for all s, t ≥ 0

This means that knowing you have waited s seconds without an event gives you no information about when the next event will occur. The process “forgets” its past.

Conditional uniformity: Given N(T) = n, the event times t_1, ..., t_n are distributed as the order statistics of n independent Uniform(0, T) random variables. This is a beautiful and useful characterization.

2.3 Simulation: Method 1 — Sequential Inter-Arrivals

The most direct simulation method uses the inter-arrival characterization:

def simulate_hpp_sequential(rate, T):
    times = []
    t = 0.0
    while True:
        t += np.random.exponential(1.0 / rate)
        if t > T:
            break
        times.append(t)
    return np.array(times)

Each call to np.random.exponential draws the next waiting time. This is simple, exact, and runs in O(n) time where n = λT is the expected number of events.

2.4 Simulation: Method 2 — Fixed-Count (Inverse CDF)

An alternative uses the conditional uniformity property:

1. Draw the total count n ~ Poisson(λT)
2. Draw n uniform random variables on [0, T]
3. Sort them

def simulate_hpp_fixedcount(rate, T):
    n = np.random.poisson(rate * T)
    times = np.sort(np.random.uniform(0, T, size=n))
    return times

Both methods are exact and produce identically distributed results. Method 2 is sometimes faster in vectorized settings because it avoids a Python loop.

2.5 Visualization

A standard visualization combines the event raster (vertical tick marks at each event time) with the counting process N(t) (staircase function):

import numpy as np
import matplotlib.pyplot as plt

events = simulate_hpp_sequential(rate=2.0, T=10.0)
t_grid = np.linspace(0, 10, 1000)
N_t = np.searchsorted(events, t_grid, side='right')

fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 5))
ax1.vlines(events, 0, 1)
ax1.set_ylabel("Events")
ax2.step(t_grid, N_t, where='post')
ax2.set_ylabel("N(t)")
plt.tight_layout()
plt.show()

See code/02_homogeneous_poisson.py for the full script with additional diagnostics.

2.6 Testing for Poissonness

Given observed event times, how do we test whether they come from an HPP?

Inter-arrival test: Check whether the inter-arrival times are exponentially distributed using a KS test:

from scipy import stats
inter_arrivals = np.diff(np.concatenate([[0], events]))
rate_hat = 1.0 / inter_arrivals.mean()
ks_stat, p_value = stats.kstest(inter_arrivals, 'expon', args=(0, 1/rate_hat))

Fano factor test: For large windows, compute Var[N] / E[N] in non-overlapping windows. It should be close to 1.

Lewis test: Under the HPP, the event times rescaled to [0,1] (i.e., tᵢ/T) should be uniform. Apply a KS or Anderson-Darling test.

2.7 Key Takeaways

• The HPP is characterized by a constant rate λ, independent increments, and exponential inter-arrivals.
• Simulation is trivial: either sample inter-arrivals from Exp(λ) or use the fixed-count method.
• The Fano factor equals 1 and the conditional distribution of event times given their count is uniform — both are testable signatures of the HPP.
• Any deviation from F = 1 or from exponential inter-arrivals signals that a richer model is needed.