Selecting infection, progression or recovery events

Once the waiting time has been generated, the CTMC must decide which of the currently possible biological events causes the next jump.

Keep “when?” and “which?” separate

When?

The total rate \(a_0\) determines the exponential waiting time.

Completed in Lesson 3

Which?

Each event's rate as a proportion of \(a_0\) determines its conditional selection probability.

This lesson

This page assumes that a jump is about to occur. It selects the event type but does not yet update the state.

Scenario: three competing SEIR events

At the current state:

\[ (S,E,I,R)=(990,5,5,0), \qquad N=1000, \]

use \(\beta=0.3\), \(\sigma=0.2\) and \(\gamma=0.1\) per day.

Infection

\[a_1=\beta SI/N=1.485.\]

Progression

\[a_2=\sigma E=1.000.\]

Recovery

\[a_3=\gamma I=0.500.\]

The total rate is:

\[ a_0=a_1+a_2+a_3=2.985\text{ events/day}. \]

Normalise rates into event probabilities

Given that the next jump occurs, event \(k\) is selected with probability:

\[ \Pr(\text{event }k\mid\text{a jump occurs}) = \frac{a_k}{a_0}. \]

Therefore:

\[ \begin{aligned} p_{\mathrm{infection}}&=1.485/2.985\approx0.4975,\\ p_{\mathrm{progression}}&=1.000/2.985\approx0.3350,\\ p_{\mathrm{recovery}}&=0.500/2.985\approx0.1675. \end{aligned} \]

The rates have units of events per day, but the units cancel in each ratio. The resulting event probabilities are dimensionless and sum to 1.

Why there is no “no-change event” here

This selection is conditional on a CTMC jump occurring. Therefore one of the positive-rate biological events must be selected.

Fixed-step DTMC	Event-driven CTMC
A fixed step may contain no event, so no change is a transition category.	The exponential waiting time already represents how long the state remains unchanged.
Event probabilities plus no-change probability sum to 1.	Conditional probabilities of currently possible events sum to 1.

Adding a no-change category to the conditional CTMC event selection would double-count waiting.

Construct cumulative intervals

Generate \(U\sim\operatorname{Uniform}(0,1)\) and place the conditional probabilities beside one another:

Uniform interval	Length	Selected event
\(0\le U<0.4975\)	0.4975	Infection
\(0.4975\le U<0.8325\)	0.3350	Progression
\(0.8325\le U<1\)	0.1675	Recovery

The second boundary is cumulative:

\[ 0.8325 = p_{\mathrm{infection}} + p_{\mathrm{progression}}. \]

Translate the intervals into Python

if u < p_infection:
    event = "infection"
elif u < p_infection + p_progression:
    event = "progression"
else:
    event = "recovery"

Reaching elif already means the infection condition was false. Reaching else means the uniform value lies in the remaining recovery interval.

The event order is not biologically important. Another order gives the same event probabilities if its cumulative boundaries are constructed consistently.

Why larger rates are selected more often

The interval assigned to an event has length \(a_k/a_0\). Therefore an event with twice the rate receives twice the interval length and is selected approximately twice as often over many repetitions at the same state.

This does not mean it must occur in any particular single selection. A low-rate event can still be selected.

Boundary and zero-rate events

If \(S=0\)

Infection rate is zero, so the infection interval has zero length.

If \(E=0\)

Progression rate is zero, so progression cannot be selected.

If \(I=0\)

Infection and recovery rates are zero, but progression may remain possible when \(E>0\).

If every event rate is zero, then \(a_0=0\). No event can be selected and the state is absorbing. The program must stop before dividing by \(a_0\).

Conditions for valid event selection

Every event rate must be non-negative.
The total rate must equal the sum of all current event rates.
The total rate must be positive before normalisation.
Conditional probabilities must lie in \([0,1]\) and sum to 1.
Only events allowed by the current biological state should have positive rates.

Interactive Python laboratory

The code selects one event and then repeats the selection 20,000 times without changing the state, solely to verify that empirical event proportions approach the conditional probabilities.

Interactive PythonSelect one CTMC event type

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

def event_probabilities(rates):
    rates = np.array(rates, dtype=float)

if (rates < 0).any():
        raise ValueError("Event rates cannot be negative.")

total_rate = rates.sum()

if total_rate == 0:
        raise ValueError(
            "No event is possible because the total rate is zero."
        )

probabilities = rates / total_rate

if not np.isclose(probabilities.sum(), 1.0):
        raise ValueError("Event probabilities do not sum to 1.")

return total_rate, probabilities

def select_event(u, event_names, probabilities):
    cumulative = np.cumsum(probabilities)

if u < cumulative[0]:
        return event_names[0]
    elif u < cumulative[1]:
        return event_names[1]
    else:
        return event_names[2]

# Current SEIR state and parameters
S, E, I, R = 990, 5, 5, 0
N = S + E + I + R

beta = 0.30
sigma = 0.20
gamma = 0.10

event_names = np.array([
    "infection",
    "progression",
    "recovery"
])

rates = np.array([
    beta * S * I / N,
    sigma * E,
    gamma * I
])

total_rate, probabilities = event_probabilities(rates)
cumulative_boundaries = np.cumsum(probabilities)

# Select one event
seed = 7
rng = np.random.default_rng(seed)
u = rng.random()
selected_event = select_event(
    u, event_names, probabilities
)

selection_table = pd.DataFrame({
    "event": event_names,
    "rate (events/day)": rates,
    "conditional probability": probabilities,
    "cumulative upper boundary": cumulative_boundaries
})

print(f"Total rate: {total_rate:.4f} events/day")
print(selection_table.round(6).to_string(index=False))
print()
print(f"Uniform value u: {u:.6f}")
print(f"Selected event: {selected_event}")

# Repeat only to verify the conditional probabilities
number_of_selections = 20000
counts = {
    "infection": 0,
    "progression": 0,
    "recovery": 0
}

for selection in range(number_of_selections):
    u = rng.random()
    event = select_event(u, event_names, probabilities)
    counts[event] += 1

observed_proportions = np.array([
    counts[event] / number_of_selections
    for event in event_names
])

comparison_table = pd.DataFrame({
    "event": event_names,
    "theoretical probability": probabilities,
    "observed proportion": observed_proportions
})

print()
print(f"Comparison after {number_of_selections} selections")
print(comparison_table.round(5).to_string(index=False))

x = np.arange(len(event_names))
width = 0.36

plt.figure(figsize=(8.5, 4.8))
plt.bar(
    x - width/2,
    probabilities,
    width,
    label="Theoretical probability",
    color="#39815e"
)
plt.bar(
    x + width/2,
    observed_proportions,
    width,
    label="Observed proportion",
    color="#9fc8b1"
)
plt.xticks(x, ["Infection", "Progression", "Recovery"])
plt.ylabel("Conditional probability or proportion")
plt.ylim(0, 0.60)
plt.title("Event selection follows relative transition rates")
plt.legend()
plt.grid(axis="y", alpha=0.25)
plt.tight_layout()

Output

Run the code to see the result.

Understand the new code

Code	Meaning
`rates / total_rate`	Normalises rates into dimensionless conditional event probabilities.
`np.cumsum(probabilities)`	Calculates cumulative upper interval boundaries.
`counts[event] += 1`	Adds one to the count belonging to the selected event name.
`np.isclose(...)`	Checks a floating-point probability sum using a small numerical tolerance.

Biological interpretation

At this state, infection has the largest transition rate and therefore the largest conditional probability of being the next event. Progression is the next most likely, and recovery has the smallest interval.

The repeated selections keep the state fixed only to verify the rate-ratio rule. A real CTMC simulation updates the state after one selected event and then recalculates every rate before proceeding.

What this lesson has—and has not—done

You can now:

normalise competing event rates by their total;
interpret the result as event type conditional on a jump;
construct cumulative uniform intervals;
handle zero-rate and zero-total-rate cases; and
verify selections using repeated fixed-state experiments.

Not yet: Lesson 5 combines one exponential waiting time, one event selection and the corresponding compartment update to program one complete CTMC event.