Why Compute Erlang B Recursively?
In an Erlang loss system, a customer who arrives when all servers are busy is turned away; there is no waiting room. The blocking probability can be expressed using a finite sum, but that expression contains factorials and powers that become inconvenient as the number of servers grows. A short recursion computes the same probability one server count at a time, keeping the quantities of interest between zero and one.
Let \(c\) be a positive integer, let \(\lambda\ge0\) be the arrival rate, and let \(\mu>0\) be the service rate of each server. The offered load is \(a=\lambda/\mu\). The system has \(c\) servers and no waiting places. Its occupancy process \((X_t)_{t\ge0}\), on a probability space \((\Omega,\mathcal{F},\mathbb{P})\), is a continuous-time process with state space \(S=\{0,1,\ldots,c\}\); we use its natural filtration \(\mathcal{F}_t=\sigma(X_s:0\le s\le t)\). When \(a>0\), the Erlang B blocking probability is the stationary probability that all \(c\) servers are busy, equivalently the probability an arriving Poisson customer is blocked. The Erlang B formula is
For the recursion, define \(B(0,a)=1\). This is the algebraic boundary convention: with zero servers every offered customer is blocked. When \(a=0\), no customers arrive, so a blocking probability conditional on an arrival is not operationally defined; for \(c\ge1\), the formula gives \(B(c,0)=0\), its natural limiting value as the offered load decreases to zero.
This recursion is used forward in the server count: start at \(B(0,a)\), then calculate \(B(1,a),B(2,a),\ldots,B(c,a)\). It does not require a factorial or the direct evaluation of a sum whose terms may be very large. The derivation also explains why the previous server count’s blocking probability is exactly the quantity needed.
Deriving the Recursion
Write \(E_c(a)=\sum_{k=0}^{c}a^k/k!\), and, for \(c\ge1\), write \(x=a^c/c!\) and \(D=E_{c-1}(a)\). Then \(E_c(a)=D+x\), so the finite-sum formula gives \(B(c,a)=x/(D+x)\). Also, the previous value is \(B(c-1,a)=(a^{c-1}/(c-1)!)/D\) when \(c>1\). For \(c=1\), the boundary value \(B(0,a)=1\) gives the same identity needed below. In both cases, multiplying by \(a\) yields \(aB(c-1,a)=cx/D\). These relations turn the finite-sum expression into the recursion.
Proof. Fix \(a\ge0\) and an integer \(c\ge1\). Set \(D=E_{c-1}(a)\) and \(x=a^c/c!\). Since the term \(k=0\) in \(D\) is \(1\), \(D>0\), and \(E_c(a)=D+x\). For \(c>1\), the definition of \(B(c-1,a)\) gives $$ aB(c-1,a) =a\frac{a^{c-1}/(c-1)!}{D} =\frac{c\,a^c/c!}{D} =\frac{cx}{D}. $$ For \(c=1\), \(D=E_0(a)=1\), \(x=a\), and the boundary value gives \(aB(0,a)=a=cx/D\), so the identity holds in this case as well. Consequently, $$ \frac{aB(c-1,a)}{c+aB(c-1,a)} =\frac{cx/D}{c+cx/D} =\frac{cx}{cD+cx} =\frac{x}{D+x} =B(c,a). $$ The cancellations are valid because \(c>0\) and \(D>0\); they do not require \(a>0\) or \(x>0\). In particular, when \(a=0\), both sides of the claimed recursion are zero for \(c\ge1\). \(\square\)
The proof establishes the formula, but computation also needs a trustworthy initialization and update. The next result makes the algorithmic point precise: repeated updates starting at the boundary value return the Erlang B values, and every computed value remains a valid probability.
Proof. At \(j=0\), \(b_0=1=B(0,a)\), and \(b_0\) lies in \([0,1]\). Suppose \(j\ge1\) and \(b_{j-1}=B(j-1,a)\in[0,1]\). The recursion just proved gives \(b_j=B(j,a)\). Its numerator \(ab_{j-1}\) is nonnegative, and its denominator \(j+ab_{j-1}\) is positive. The denominator is at least the numerator because their difference is \(j>0\). Hence \(0\le b_j\le1\). Induction proves both claims for every \(j\). \(\square\)
Worked Calculations
Worked Example: Four Servers at Offered Load Two
Compute \(B(4,2)\) recursively, showing each update and checking the result against the finite-sum formula.
The boundary value is \(B(0,2)=1\). For one server, $$ B(1,2)=\frac{2\cdot1}{1+2\cdot1}=\frac23. $$ For two servers, $$ B(2,2)=\frac{2\cdot(2/3)}{2+2\cdot(2/3)} =\frac{4/3}{10/3}=\frac25. $$ For three servers, $$ B(3,2)=\frac{2\cdot(2/5)}{3+2\cdot(2/5)} =\frac{4/5}{19/5}=\frac4{19}. $$ For four servers, $$ B(4,2)=\frac{2\cdot(4/19)}{4+2\cdot(4/19)} =\frac{8/19}{84/19}=\frac2{21}. $$
Check by the finite sum. The denominator is $$ 1+2+\frac{2^2}{2!}+\frac{2^3}{3!}+\frac{2^4}{4!} =1+2+2+\frac43+\frac23=7. $$ The numerator is \(2^4/4!=16/24=2/3\), so the ratio is \((2/3)/7=2/21\), as computed recursively.
Worked Example: Three Servers at Offered Load Six
Find the blocking probability for \(c=3\) and \(a=6\). This example illustrates that a load greater than the server count is still handled by the same recursion.
Start with \(B(0,6)=1\). Then $$ B(1,6)=\frac{6}{1+6}=\frac67. $$ The next update is $$ B(2,6)=\frac{6\cdot(6/7)}{2+6\cdot(6/7)} =\frac{36/7}{50/7}=\frac{18}{25}. $$ Finally, $$ B(3,6)=\frac{6\cdot(18/25)}{3+6\cdot(18/25)} =\frac{108/25}{183/25}=\frac{36}{61}. $$
Check by the finite sum. Its denominator is $$ 1+6+\frac{6^2}{2!}+\frac{6^3}{3!}=1+6+18+36=61, $$ and its numerator is \(6^3/3!=216/6=36\). Thus the ratio is \(36/61\), confirming the recursive value. It is less than one, as a probability must be.
Worked Example: Five Servers at Offered Load Three
Compute \(B(5,3)\) and verify the last recursive update using the original formula.
With \(B(0,3)=1\), the successive values are $$ B(1,3)=\frac{3}{1+3}=\frac34, $$ $$ B(2,3)=\frac{3\cdot(3/4)}{2+3\cdot(3/4)} =\frac{9/4}{17/4}=\frac9{17}, $$ $$ B(3,3)=\frac{3\cdot(9/17)}{3+3\cdot(9/17)} =\frac{27/17}{78/17}=\frac9{26}, $$ $$ B(4,3)=\frac{3\cdot(9/26)}{4+3\cdot(9/26)} =\frac{27/26}{131/26}=\frac{27}{131}, $$ and $$ B(5,3)=\frac{3\cdot(27/131)}{5+3\cdot(27/131)} =\frac{81/131}{736/131}=\frac{81}{736}. $$
Check by the finite sum. The denominator is $$ 1+3+\frac{3^2}{2!}+\frac{3^3}{3!}+\frac{3^4}{4!}+\frac{3^5}{5!} =1+3+\frac92+\frac92+\frac{27}{8}+\frac{81}{40} =\frac{736}{40}. $$ The numerator is \(3^5/5!=243/120=81/40\), so the ratio is \((81/40)/(736/40)=81/736\). This agrees with the recursion.
Using the Recursion Reliably
For a fixed offered load \(a\), the calculation needs one update for each server count from \(1\) through \(c\). Only the current value needs to be retained, so the calculation takes \(c\) updates and constant storage. This is useful when \(c!\) or the terms \(a^k/k!\) would be too large to evaluate directly. The recurrence also avoids subtracting nearly equal quantities: each update forms a ratio of nonnegative terms.
For ordinary finite inputs, the recurrence directly gives a convenient numerical scheme. Its output is bounded by one, as the proposition proves. That does not mean every possible floating-point implementation is immune to overflow: the intermediate product \(aB(c-1,a)\) can overflow if \(a\) is extremely large in the machine’s numeric range. A practical implementation can use the equivalent expression \(B(c,a)=r/(1+r)\), where \(r=aB(c-1,a)/c\), and, when the scale is extreme, evaluate it from \(\log r=\log a+\log B(c-1,a)-\log c\) with a stable logistic calculation. The special case \(a=0\) is handled directly by setting \(B(0,0)=1\) and \(B(c,0)=0\) for \(c\ge1\), rather than taking logarithms.
The recursion is also convenient for sensitivity comparisons across server counts: a single run produces every value \(B(1,a),\ldots,B(c,a)\). Each step depends on the previous value, so a change in server count must be computed by continuing the sequence, not by inserting \(c\) into a one-step formula with an unrelated starting value. The direct finite sum remains a useful independent check for small examples, but the recursion is generally simpler for larger \(c\).
Common mistake: omitting the previous blocking probability from the denominator. For \(a=2\), the first update gives \(B(1,2)=2/3\). A mistaken expression \(aB(c-1,a)/(c+a)\) would give, at \(c=2\), $$ \frac{2\cdot(2/3)}{2+2}=\frac13, $$ which is not the Erlang B value. The correct denominator is \(c+aB(c-1,a)\), so the update is $$ \frac{2\cdot(2/3)}{2+2\cdot(2/3)} =\frac{4/3}{10/3}=\frac25. $$ The finite-sum check gives \((2^2/2!)/(1+2+2)=2/5\), confirming the correction. Another consequential error is initializing at zero: since every update then has zero numerator, it would incorrectly return zero for every server count. The boundary value \(B(0,a)=1\) is essential.
Check Your Understanding
Use the recursion and, where requested, verify your result by substituting into the finite-sum formula.
- Starting from \(B(0,1)=1\), compute \(B(1,1)\), \(B(2,1)\), and \(B(3,1)\).
- For \(a=4\), compute \(B(1,4)\) and \(B(2,4)\). Show the numerator and denominator of each update.
- Why is \(B(0,a)=1\) the appropriate algebraic boundary value for the recursion?
- Explain why the recursion’s denominator is positive for every \(c\ge1\) and \(a\ge0\).
- Identify the error in using \(aB(c-1,a)/(c+a)\), and check the correction at \(c=2,\ a=2\).