Realizing Common Random Numbers: Event-Keyed Hashing for Causally Valid Stochastic Models

This paper argues that standard stateful pseudorandom number generators undermine the causal validity of agent-based models by linking random draws to execution order rather than specific events, and proposes using event-keyed hashing with counter-based generators to restore causally coherent paired counterfactual comparisons.

The Gist

Here is an explanation of the paper using simple language and creative analogies.

The Big Problem: The "Broken Tape Recorder"

Imagine you are a scientist trying to figure out if a new vaccine works. You have a super-complex computer simulation of a city with thousands of people. To test the vaccine, you run the simulation twice:

1. Scenario A (Baseline): No one gets the vaccine.
2. Scenario B (Intervention): Everyone gets the vaccine.

To get a fair comparison, you need to make sure the "randomness" in the simulation is identical in both runs. You want to ask: "If we took this exact same person, with this exact same bad luck, and gave them the vaccine, would they get sick?"

This technique is called Common Random Numbers (CRNs). It's like running a race with two identical twins on the same track, in the same weather, at the same time. You only change one thing: whether they wear running shoes or not.

The Flaw:
The paper argues that most scientists are using a broken method to generate this "bad luck." They use a standard computer tool called a Stateful Pseudorandom Number Generator (PRNG).

Think of a Stateful PRNG as a tape recorder that plays a long, pre-recorded list of random numbers (like a playlist).

• In Scenario A, the tape plays: Number 1, Number 2, Number 3...
  • Number 1 decides if Person A gets sick.
  • Number 2 decides how long Person A is sick.
  • Number 3 decides if Person B gets sick.
• In Scenario B (with the vaccine), Person A doesn't get sick because the vaccine worked.
  • Because Person A didn't get sick, the simulation skips the step where it asks "How long are they sick?"
  • The Tape Recorder skips Number 2!
  • Now, the simulation uses Number 3 to decide if Person B gets sick.

The Disaster:
In Scenario A, Person B was judged by Number 3. In Scenario B, Person B is judged by Number 2.
You are no longer comparing the same person under different conditions. You are comparing Person B's "bad luck" in one universe to Person B's "good luck" in another. The comparison is broken. The "bad luck" (the random noise) has shifted because the path the computer took to get there changed.

The Solution: The "Address Book" System

The authors propose a new way to handle randomness called Event-Keyed Hashing.

Instead of a tape recorder that plays numbers in a line, imagine a magic address book (or a library with infinite shelves).

• Every single event in the simulation (e.g., "Person A getting sick," "Person B getting sick") has a unique, permanent address (like a GPS coordinate or a specific book title).
• The computer doesn't care what happened before. It just looks up the address: "What is the random number for 'Person B getting sick'?"
• It finds the book titled "Person B - Infection Event" and opens it to page 1.
• Scenario A: Person B gets sick. The book says "Yes."
• Scenario B: Person B gets sick (or doesn't). The computer looks up the same book, "Person B - Infection Event". It opens it to page 1 again.

Why this fixes everything:
Even if the vaccine saves Person A's life and skips a whole bunch of steps, the computer still goes straight to Person B's specific address. Person B gets the exact same random number in both scenarios.

This ensures that when you compare the two worlds, you are truly comparing the same people with the same underlying luck, only changing the intervention (the vaccine).

The "Transworld Identity" Puzzle

The paper also points out a deeper philosophical issue: What counts as the "same event"?

Imagine a hospital.

• Scenario A: Patient X sees Doctor Jones.
• Scenario B: Doctor Jones is sick, so Patient X sees Doctor Smith.

If you use the "Address Book" method, how do you label the event?

1. Slot-Keypoint: "Patient X's appointment at 9:00 AM." (The random number is tied to the time slot). If the doctor changes, the luck stays the same. This assumes the doctor doesn't matter for the randomness, only for the risk calculation.
2. Dyad-Keypoint: "Patient X meeting Doctor Jones." (The random number is tied to the specific pair). If the doctor changes, the "event" is different, so you need a new random number.

The paper argues that scientists must explicitly choose which of these rules they want. Old methods (the tape recorder) made this choice automatically and often accidentally (usually picking the wrong one). The new method forces scientists to say: "Here is exactly what I mean by 'the same event'."

Summary: Why Should You Care?

1. Fairness: Without this fix, your computer simulations might tell you a vaccine works (or fails) just because the random numbers got shuffled around, not because the vaccine actually does anything.
2. Efficiency: By keeping the random numbers aligned, you need fewer computer runs to get a clear answer. It's like taking a photo with a steady hand vs. a shaky one; you get a clearer picture with less effort.
3. Truth: It stops the computer from creating "ghost" connections. In the old method, Person A getting sick could accidentally change Person B's luck just because the computer had to skip a step. In the new method, Person A and Person B are truly independent unless the science says they are connected.

The Bottom Line:
The authors are telling the scientific community: "Stop using the tape recorder method where the order of events changes the outcome. Start using the address book method where every event has its own permanent, unchangeable ID card." This makes simulations more honest, more accurate, and truly causal.

Technical Summary

Here is a detailed technical summary of the paper "Realizing Common Random Numbers: Event-Keyed Hashing for Causally Valid Stochastic Models."

1. Problem Statement

The paper addresses a fundamental flaw in how Agent-Based Models (ABMs) implement Common Random Numbers (CRNs), a standard variance reduction technique used to estimate causal treatment effects via paired counterfactual simulations.

• The Standard Practice: Researchers typically implement CRNs by reusing the same base seed for a stateful Pseudorandom Number Generator (PRNG) across different intervention scenarios (e.g., baseline vs. vaccination). The assumption is that the $k$-th random draw in the sequence corresponds to the same modeled event in both scenarios.
• The Flaw: Stateful PRNGs (e.g., Mersenne Twister, PCG) maintain a mutable internal state that advances with every function call. If an intervention alters the simulation's execution path (e.g., a vaccine prevents an infection, thereby skipping a subsequent "incubation time" draw), the number of random draws consumed prior to downstream events changes.
• The Consequence: This creates execution-path-dependent draw indexing. Consequently, the same modeled event (e.g., "Agent 2 gets infected") receives a different random number in the intervention scenario compared to the baseline, not because the event's mechanics changed, but because the index in the random stream shifted.
• Scientific Impact: This violates the requirements of Structural Causal Models (SCMs). In a valid SCM, interventions should only alter structural equations (mechanisms), while the exogenous noise terms ($U$) must remain fixed to allow for coherent counterfactual comparisons ("what if" scenarios). The standard approach renders individual-level counterfactuals ill-defined and renders variance reduction unpredictable (sometimes increasing variance).

2. Methodology and Theoretical Framework

The authors formalize the problem using Structural Causal Models (SCMs) and propose a solution based on Counter-Based Random Number Generators (CBRNGs).

A. Theoretical Formalization (SCM Lens)

• Execution Invariance: The authors define a property called Execution Invariance. For an ABM to be causally valid, the mapping from a modeled event identity to its exogenous noise term ($U_e$) must be invariant to changes in execution history.
  • Formally: $U_e = g(s, \text{event\_ide})$, where $s$ is the seed and $\text{event\_ide}$ is a stable identifier for the event.
• The Violation: Standard stateful PRNGs implement $U_e = g(s, \text{draw\_index})$. Since the draw index depends on prior outcomes (execution path), the noise identity becomes endogenous.
  • Example: In a toy infection model, if Person 1 is vaccinated and does not get infected, the code skips a draw for incubation time. Person 2's infection draw, which was originally the 3rd draw ($R_3$), becomes the 2nd draw ($R_2$). The noise term for Person 2 changes purely due to Person 1's outcome, creating a spurious causal link ($I_1 \to \text{draw index} \to I_2$) that does not exist in the scientific model.

B. Proposed Solution: Event-Keyed Random Number Generation

The authors propose replacing stateful PRNGs with Counter-Based PRNGs (e.g., Philox, Threefry) combined with Event Identifiers.

• Mechanism: CBRNGs are purely functional (stateless). The output is a deterministic function of a key and a counter: $R = \text{Hash}(\text{seed}, \text{counter})$.
• Event-Keying: Instead of using a sequential counter, the "counter" is replaced by a composite Event Identifier ($\text{event\_ide}$) that uniquely identifies the specific stochastic event (e.g., "Infection of Agent $i$ at time $t$").
• Implementation:
  • infected = (CBRNG(seed, hash("infection", i)) < p)
  • incubation = CBRNG(seed, hash("incubation", i))
  • Because the hash depends on the event identity, skipping the incubation draw for Agent 1 does not shift the key used for Agent 2. Agent 2 always uses hash("infection", 2), ensuring $U_2$ is identical across scenarios.

C. Event Identity Design

The paper emphasizes that defining the event_ide is a substantive modeling choice, not an automated process. It determines the counterfactual semantics:

• Slot-Keyed: The event is the "contact opportunity" (e.g., Patient $i$ at time $t$). The noise is shared even if the contact partner changes. This assumes partners are exchangeable conditional on modeled state.
• Dyad-Keyed: The event is the specific "Patient-Worker pair." If the worker changes, the event identity changes, and a new noise term is drawn. This implies no valid individual-level counterfactual exists if the partner changes.
• Guidelines: Event keys must be granular enough to avoid spurious dependencies, isolated from endogenous state changes (to prevent execution history dependence), and stable across scenarios (e.g., using genealogical hashing for agent IDs to handle birth/death mismatches).

3. Key Contributions

1. Formal Identification of a Causal Mismatch: The paper rigorously proves that standard stateful PRNG implementations violate the Execution Invariance required for SCMs. It demonstrates that "seed-matching" does not guarantee "world-matching" when execution paths diverge.
2. Definition of Execution Invariance: It introduces a formal definition for what it means for a stochastic simulation to be causally coherent across intervention scenarios.
3. Event-Keyed Randomness Framework: It proposes a concrete architectural shift: combining Counter-Based PRNGs with stable Event Identifiers. This decouples random number generation from execution order.
4. Resolution of Variance Reduction Issues: It shows that this approach restores the positive covariance required for CRNs to effectively reduce Monte Carlo variance, whereas stateful PRNGs can lead to negative covariance (increasing variance).
5. Clarification of Counterfactual Semantics: The paper clarifies that choosing an event-keying strategy is a modeling decision regarding which aspects of randomness are held fixed (exogenous) versus which are allowed to vary, paralleling assumptions of exchangeability in causal inference.

4. Results and Implications

• Causal Coherence: The proposed method ensures that individual-level treatment effects ($ITE = Y^{(1)} - Y^{(0)}$) are comparisons of the same unit under different treatments with the same underlying randomness, rather than comparisons of different random events.
• Variance Reduction: By restoring stable noise alignment, the method guarantees that CRNs will reduce variance (or at least not increase it), making simulation studies more statistically efficient.
• Downstream Analysis: The approach enables valid sensitivity analysis, variance decomposition (Sobol indices), and mediation analysis, which previously were compromised by the "noise contamination" caused by shifting draw indices.
• Performance: Modern CBRNGs (like Philox/Threefry) are computationally comparable to stateful generators (within 5-10% overhead) and offer superior parallelization capabilities, making them suitable for high-performance computing environments.

5. Significance

This paper fundamentally shifts the paradigm for stochastic simulation in epidemiology and policy analysis. It argues that execution invariance is not merely an optimization detail but a core requirement for causally valid inference.

• Scientific Rigor: It prevents researchers from drawing invalid conclusions about individual-level causal effects based on simulations that inadvertently introduce spurious causal paths via PRNG state management.
• Methodological Shift: It moves the ABM community away from "stateful" thinking (mutable global state) toward "functional" thinking (pure functions of inputs), aligning simulation practices with functional programming principles.
• Reproducibility and Validity: By making the mapping between events and noise explicit and inspectable, the method enhances the reproducibility and scientific validity of counterfactual simulations, ensuring that the "what if" questions asked by models are answered with the correct logical structure.

In summary, the authors provide a necessary correction to a widespread practice in computational modeling, offering a technically robust and theoretically sound solution to ensure that stochastic simulations accurately reflect the causal structures they are intended to model.