Homework 10

Counting Process Simulation and Poisson Approximation

Introduction

In this homework, we'll study a counting process over a fixed time interval T (for example, T = 1), where events like "success" occur independently and uniformly in time at a constant average rate λ.

We approximate this process by dividing the interval into n small subintervals and, in each subinterval, generating at most one event with probability λ/n.

So, our goals in this case are:

• identify which stochastic process this approximation converges as n grows.
• discuss its theoretical properties.
• interpret the meaning of the rate parameter λ.
• validate the model via simulation.

Discrete approximation of the counting process

Time discretization

We consider the time interval [0,T] with T = 1 to keep it simple. Then, we divide into n equal subintervals of lenght Δt = T/n.

For each subinterval i = 1,2,...,n:

• an event occurs with probability p = λ/n.
• no event occurs with probability i - p.

Also, we assume that:

• there i sinterdependence between subintervals.
• there is at most one event per subinterval (which is reasonable for large n and moderate λ).

Let Xi be the indicator of an event in subinterval i: Xi can be 1 if an event occurs in subinterval i, 0 otherwise.

Then Xi tends to Bernoulli(p) with p = λ/n.

The total number of events in [0,1] is:

Thus:

Interpretation as a counting process

For each time point t ∈ [0,1], we define N(t) as the number of events occurred up to time t. So, in the discrete approximation, if t = k/n, then:

This process {N(t) : t ∈ [0,1]} is a counting process: it starts at 0 and it increases by jumps of size 1, and is non-decreasing in time.

Limit as n$\to \infty$: Poisson Process

Convergence of the count distribution

For fixed λ > 0, consider another time: 

Its probability mass function is:

This is exactly the Poisson distribution with parameter λ:

So, the discrete counting process approximates a Poisson counting process as n grows.

More generally, if we consider time t ∈ [0,1], the same reasoning leads to:

Identification of the process

The limiting process {N(t)} with t >= 0, as we redefine the time grid (for example, with n which tends to infinity), is a homogeneous Poisson process with rate λ, characterized by some key aspects:

1. N(0) = 0 almost surely.
2. independent increments: the number of events in disjoint time intervals are independent.
3. Stationary increments: for any s < t: $N(t)-N(s)\sim \text{Poisson}(\lambda (t-s))$;
4. The probability of more than one event in a sufficiently small intervall is negligible (so it goes to 0 as the interval shrinks).

Theoretical properties of the Poisson Counting Process

Distribution of N(t)

For a Poisson process with rate λ, the number of events [0,t] is N(t)∼Poisson(λt). As we mentioned before, if we use the mass function we obtain:

with k = 0,1,2,...

So, the mean and the variance in this case are E[N(t)]=λt and Var(N(t))=λt. Therefore, on average, we observe λt events in time t.

Inter-arrival times

Let t1 be the waiting time until the first event. In a Poisson process with rate λ, we have that T1​∼Exponential(λ), and if we also add density we obtain:

More generally speaking, the waiting times between consecutive events are identical and independently distributed, with exponential rate with parameter λ.

This implies the memoryless property: P(T1​>s+t∣T1​>s)=P(T1​>t).

Independent and Stationary increments

For disjoint intervals [t0, t1), [t1,t2),...:

• The counts N(t1) - N(t0), N(t2) - N(t1), ... are independent.
• Each incremement N(ti+1) - N(ti) only depends on the lenght of the interval: N(ti+1​)−N(ti​)∼Poisson(λ(ti+1​−ti​)).

This behaviour is consistent with the idea of constant average rate λ.

Interpretation of the rate parameter λ.

The rate λ has multiple equivalent interpretations in the Poisson process. In particular:

• The average number of events per unit time is E[N(1)]=λ.
• The slope of the expected count curve is E[N(t)]=λt ⇒ (d/dt)​E[N(t)]=λ.
• The inverse of the expected inter-arrival time is E[T1​]=1/λ​.

So, for example, if λ = 3 events per unit time, then we expect on average 3 events in [0,1], about 6 in [0,2] and the expected waiting time between events is 1/3.

The test

In this section, we'll simulate the discrete approximation for T = 1, using rate λ = 3, n = 5000 as the number of subintervals and m = 10000 as the number of simulated trajectories.

To do this test we'll use JavaScript as usual, the code snippet below is the
part which simulates the approximation:

At the end of the simulation, counts[k] is the number of simulations where exactly k events occurred in [0,1].

Also, we can compute the theoretical Poisson probabilities for comparison, which can still be done using JavaScript: the code snippet below shows how to calculate the Poisson probabilities.

Using this kind of setup, we obtained these results:

As we can see, the empirical frequencies are very close to the theoretical Poisson(λ) probabilities.

So, the discrete Bernoulli construction (with probability λ/n in each subinterval) produces empirical counts that match a Poisson distribution with parameter λ. Moreover, increasing m (the number of simulated paths) tightens the agreement (thanks to the Law of Large Numbers). Also, increasing n (or the fine time grid) improves the apporximation from the discrete Bernoulli model to the continuous-time Poisson process.

This numerically confirms that the dicrete counting process approximates a Poisson process with rate λ.

Conclusions

We considered a counting process on [0,1] where events occur independently with constant average rate λ. By discretizing time into n small subintervals and generating Bernoulli events with probability λ/n, we obtained a binomial model for the total number of events, which converges to a Poisson distribution as n tends to infinity.

The limiting process is a homogenous Poisson process with rate λ, characterized by:

• Poisson-distributed counts N(t)$\sim \text{Poisson}(\lambda t).$
• $Independent\; and\; stationary\; increments.$
• $Exponentially\; distributed\; inter-arrival\; times\; with\; parameter$$\lambda .$
• $Clear\; physical\; interpretation\; of$$\lambda \; as\; the\; average\; rate\; of\; events\; per\; unit\; time.$

The simulation in JavaScript empirically confirms the convergence of the discrete approximation to the Poisson model, both in terms of the distribution of counts and the interpretation of the rate parameter.