Birth–Death Processes

Picture a quantity that ticks up and down one unit at a time: the number of customers in a queue, the size of a population, the count of busy servers, the jobs in a printer's buffer. It grows by a birth (an arrival, a new individual) and shrinks by a death (a departure, a loss) — and crucially, never by leaps of two or more at once. A continuous-time model of exactly this up-one-down-one motion is a birth–death process. It is the single most important special case of a continuous-time Markov chain, and the machinery we build here is precisely what powers the M/M/1 queue and its whole family of cousins.

Births, deaths and the state diagram

The state n = 0, 1, 2, \dots is the current population (or queue length). From state n the process jumps up to n{+}1 at the birth rate \lambda_n, and down to n{-}1 at the death rate \mu_n. Allowing the rates to depend on the state n is what makes the model flexible — a queue with more servers clears faster when it is busier, a population breeds more slowly when it is crowded.

The picture is a chain of states with birth arrows pushing right and death arrows pulling left. Notice state 0 has no death arrow — you cannot fall below an empty queue.

The balance equations

In the long run the process reaches a stationary distribution P_n = the fraction of time spent in state n. The elegant way to find it is flow balance: in steady state, the rate at which probability flows across any boundary must match in both directions — rate in = rate out.

Draw a cut between states n and n{+}1. Probability crosses rightward only by a birth out of n (rate \lambda_n P_n) and leftward only by a death out of n{+}1 (rate \mu_{n+1} P_{n+1}). Balancing them:

This "rate in = rate out" trick sidesteps solving a big linear system: the chain's one-step structure lets us cross one boundary at a time.

The stationary distribution as a product

Cascade the ratio relation from the bottom and every probability is expressed through P_0:

P_n = P_0 \prod_{i=0}^{n-1} \frac{\lambda_i}{\mu_{i+1}}, \qquad P_0 = \left(1 + \sum_{n=1}^{\infty} \prod_{i=0}^{n-1} \frac{\lambda_i}{\mu_{i+1}}\right)^{-1}.

The last equation just forces the probabilities to sum to 1. Every stationary result for this whole class of models is a special case of these two formulas.

Collapse to M/M/1

Take the simplest case: constant rates \lambda_n = \lambda and \mu_n = \mu for all n. Then every ratio is the same number \rho = \lambda/\mu, and the product becomes a power:

P_n = P_0\,\rho^{\,n}, \qquad P_0 = 1 - \rho, \qquad P_n = (1-\rho)\rho^{\,n}.

That is the geometric distribution of queue length in the single-server M/M/1 queue — derived here in two lines from flow balance, with no queue-specific cleverness at all. Change the rate pattern (make \mu_n = n\mu for many servers, cap the state for a finite waiting room) and the same product formula spits out the answer for every classical queue.

In steady state the probability sitting in each state is not changing, even though probability is constantly sloshing between states. Think of each state as a tank of water at a fixed level: the level holds still precisely because inflow equals outflow. For a general Markov chain you balance the flows into and out of each state. Birth–death chains are special because motion is only ever to a neighbour, so you can slice the chain with a single vertical cut and balance just the two flows crossing it — a far simpler bookkeeping than the full global balance, and the reason these models are so tractable.

The product formula only defines a genuine probability distribution if the normalising sum converges. If births consistently outpace deaths — \lambda_n/\mu_{n+1} staying at or above 1 — the terms do not shrink, the sum diverges, and there is no stationary distribution: the population drifts to infinity and the queue grows without bound. For the constant-rate case this is exactly the M/M/1 stability condition \rho < 1. Always check convergence before quoting a P_n: a formula that sums to infinity is describing a system that never settles.