Snapshot-Restart Monte Carlo Methods

• Snapshot-Restart Monte Carlo is a methodological umbrella that stores simulation checkpoints to resume runs deterministically or with fresh randomness, ensuring statistical validity.
• It enhances Monte Carlo methods through fixed-level splitting, adaptive population control, and auxiliary randomness snapshotting to reduce variance and manage rare events.
• The approach underpins applications from resilient network modeling to adaptive MCMC and anytime Monte Carlo, offering efficient mitigation strategies and real-time computation.

Searching arXiv for the cited papers and closely related work. Searching for "Sequential Monte Carlo for Resilient Networks: Assessment, Mitigation, and Generative Modeling" and related snapshot-restart Monte Carlo papers. Snapshot-Restart Monte Carlo denotes Monte Carlo procedures that store simulation state as a checkpoint or “snapshot” and later use that state to resume a run, branch multiple continuations, or renew statistically independent attempts from a fixed starting condition. In the literature represented here, the term covers several distinct but related constructions: fixed-level splitting in sequential Monte Carlo for path-dependent rare events, RESTART/DPR-style branching in diffusion Monte Carlo, deterministic checkpoint-resume in adaptive MCMC software, interruption-safe anytime Monte Carlo under real-time budgets, and augmented-state methods in which auxiliary randomness itself is snapshotted (López et al., 6 May 2026, Hairer et al., 2012, Shahmoradi et al., 2020, Kumbhare et al., 2020, Murray et al., 2016, Frenkel et al., 2016). This suggests that “Snapshot-Restart Monte Carlo” is best understood as a methodological umbrella rather than a single canonical algorithm.

1. Terminology, scope, and recurring structure

Across these usages, a snapshot is the stored state required to continue a stochastic simulation without re-simulating the full prefix. A restart is then either a continuation from that state with fresh randomness, or an exact deterministic resume of the same stochastic computation when interruption occurs. The common motif is selective reuse of state while preserving either statistical validity or deterministic reproducibility.

Usage	Snapshot	Restart function
Fixed-level SMC	First-hitting checkpoint at a level	Spawn new continuations in rare-event regions
Ticketed DMC	Propagated parent state plus ticket	Split or kill descendants under RESTART/DPR logic
Adaptive MCMC software	PRNG state, chain state, adaptation state, counters	Deterministic continuation after interruption
Anytime MC	Chain states, lag, scheduling state	Resume under a wall-clock budget without returning biased states
Noisy-weight pseudo-marginal MC	State plus auxiliary randomness	Refresh or carry stochastic weights exactly

A further commonality is that the snapshot must include all state variables needed for Markovian continuation. In rare-event splitting this means the full simulator state at first hitting; in adaptive MCMC it includes proposal-covariance state and delayed-rejection context; in pseudo-marginal methods it includes the auxiliary randomness generating the noisy weight; and in anytime Monte Carlo it includes the lag or scheduling pointer, because observation at a wall-clock time otherwise induces length bias (López et al., 6 May 2026, Shahmoradi et al., 2020, Kumbhare et al., 2020, Murray et al., 2016, Frenkel et al., 2016).

2. Fixed-level splitting as snapshot-restart SMC

In “Sequential Monte Carlo for Resilient Networks: Assessment, Mitigation, and Generative Modeling” (López et al., 6 May 2026), Snapshot-Restart Monte Carlo is realized by a sequential Monte Carlo scheme that stores and reuses trajectory checkpoints at progressively more critical resilience levels, and restarts many continuations from those states to amplify sampling of rare, path-dependent failure events. The framework defines a reaction coordinate $g(X)$ and nested level sets

$L_k = \{x \in X : g(x) \ge \ell_k\},$

with $\ell_0=-\infty$ so $L_0=X$, and $\ell_K$ chosen so that $L_K \subseteq F$, the rare failure set. The failure event is

$\xi = \{\exists t \le T : X(t) \in F\}.$

The rare-event probability factorizes as

$$p = \Pr(\xi) = \prod_{k=0}^{K-1} p_k, \qquad p_k = \Pr(\xi_{k+1}\mid \xi_k),$$

where $\xi_k=\{\exists t \le T : X(t)\in L_k\}$.

The paper’s fixed-level splitting estimator is the product of stage estimates. In the classical unweighted scheme, $\hat p_k=S_k/M$ with maintained population $L_k = \{x \in X : g(x) \ge \ell_k\},$0 and stage successes $L_k = \{x \in X : g(x) \ge \ell_k\},$1. In the budget-aware version,

$L_k = \{x \in X : g(x) \ge \ell_k\},$2

where $L_k = \{x \in X : g(x) \ge \ell_k\},$3 is the number of attempted continuations at level $L_k = \{x \in X : g(x) \ge \ell_k\},$4. With fixed levels, i.i.d. restarts, and no outcome-dependent stopping, the estimator is unbiased; the budget-aware stopping criteria introduce a small positive bias that vanishes as success or attempt targets grow. The scheme is unweighted, resampling is uniform among successful first-hitting checkpoints, and effective sample size is therefore trivial.

Algorithmically, each stage maintains a pool of checkpoints $L_k = \{x \in X : g(x) \ge \ell_k\},$5. A continuation samples a checkpoint from $L_k = \{x \in X : g(x) \ge \ell_k\},$6 with replacement, simulates forward with fresh randomness, and stops at the first hit of $L_k = \{x \in X : g(x) \ge \ell_k\},$7, at the terminal horizon, or upon premature absorption in failure. Only first-hitting checkpoints are stored. If $L_k = \{x \in X : g(x) \ge \ell_k\},$8 or $L_k = \{x \in X : g(x) \ge \ell_k\},$9, the algorithm terminates with $\ell_0=-\infty$0 under the available budget. Otherwise it estimates $\ell_0=-\infty$1 and sets the next pool size adaptively through

$\ell_0=-\infty$2

This budget-aware population control increases the population at difficult transitions, bounds growth through $\ell_0=-\infty$3 and $\ell_0=-\infty$4, and uses global budget $\ell_0=-\infty$5 to cap total simulator steps.

The same paper formulates resilience failures as path-dependent events with staged degradation and delayed recovery. In the delay-critical wireless use case, the discrete-time state is

$\ell_0=-\infty$6

where $\ell_0=-\infty$7 is backlog, $\ell_0=-\infty$8 is normalized service capacity, $\ell_0=-\infty$9 is latent stress, and $L_0=X$0 is a persistence counter. The reaction coordinate is

$L_0=X$1

with example fixed levels $L_0=X$2, $L_0=X$3, $L_0=X$4, $L_0=X$5, and $L_0=X$6. The non-recovery failure event is

$L_0=X$7

equivalently $L_0=X$8.

This formulation makes the checkpoints semantically interpretable. The levels correspond to resilience phases such as nominal, degraded, critical affectation, near failure, and non-recovery, so snapshots are not merely computational artifacts: they are standardized near-critical states that can be reused for policy evaluation, mitigation selection, and downstream simulation, provided that continuations use fresh randomness and the levels remain policy-invariant.

3. Learned restartable surrogates and checkpoint-based decision support

The same framework extends snapshot-restart logic to learned stochastic simulation in a data-driven digital twin (López et al., 6 May 2026). The paper trains a conditional generative sequence model that receives a history window and a criticality context and generates future blocks of system variables. The encoder uses a GRU for normalized log-delay history, an MLP for the criticality context $L_0=X$9, and another MLP for the last observed delay $\ell_K$0, with the three embeddings fused into a conditioning vector $\ell_K$1. The generator is a conditional DDPM with a 1D U-Net along time, predicting injected noise $\ell_K$2 and synthesizing the future block through reverse diffusion; DDIM-style subsampled reverse steps are used at inference.

Training uses the standard noise-prediction loss

$\ell_K$3

together with criticality-aware weighting so that windows at higher levels and future samples exceeding $\ell_K$4 receive larger weights. The dataset is grouped by level via $\ell_K$5 and sampled under a balanced, criticality-aware mixture with caps per level; transition windows where the level index changes between consecutive times are included explicitly so that the surrogate learns staged degradation, persistence, recovery, and near-failure transitions.

At runtime, when SMC requires a continuation from a checkpoint, the surrogate takes the checkpoint-derived history window and context $\ell_K$6 and generates future blocks autoregressively, updating $\ell_K$7 and $\ell_K$8 as the rollout proceeds until the next level, recovery, failure, or horizon. The paper validates the surrogate by comparing trajectory-level delay mean and standard deviation over time and persistence distributions, specifically the longest continuous threshold-exceedance run. No explicit likelihood weighting or discrepancy correction is applied beyond training-time reweighting and DDIM inference sampling.

The wireless-network case study quantifies the computational effect of checkpointing. Under equal total simulator steps, naive Monte Carlo can only simulate approximately $\ell_K$9 full trajectories in one setup, yielding a resolution floor of approximately $L_K \subseteq F$0. With $L_K \subseteq F$1 levels and $L_K \subseteq F$2 minimum attempts per level, SMC can conservatively resolve probabilities down to $L_K \subseteq F$3. Estimated non-recovery probability curves versus $L_K \subseteq F$4 and $L_K \subseteq F$5 show that SMC dominates MC in rare regimes with $L_K \subseteq F$6 under both the physical simulator and the DDPM surrogate.

Checkpoint reuse also supports mitigation selection. At first entry to $L_K \subseteq F$7, candidate policies $L_K \subseteq F$8 alter the recovery rate through

$L_K \subseteq F$9

The algorithm branches $\xi = \{\exists t \le T : X(t) \in F\}.$0 continuations from the same checkpoint and selects the policy minimizing

$\xi = \{\exists t \le T : X(t) \in F\}.$1

The reported behavior is that larger policy sets yield better recovery-cost trade-offs; under low stress, lower-cost policies are preferred; and as stress variability increases, more aggressive policies are selected more frequently. To preserve causality and avoid bias, decision-support runs are not reused in the main simulation, and the selected policy is applied from $\xi = \{\exists t \le T : X(t) \in F\}.$2 onward with fresh randomness.

4. RESTART, DPR, and ticketed diffusion Monte Carlo

“Improved diffusion Monte Carlo” modifies standard diffusion Monte Carlo by incorporating ideas from RESTART and DPR (Hairer et al., 2012). The classical RESTART algorithm splits a trajectory when it crosses predefined level sets and restricts descendants to specified regions, eliminating them when they exit. DPR redistributes probability mass at splitting events to control variance while maintaining unbiasedness. The paper’s ticketed DMC implements these ideas through particle-specific constraints called tickets.

The generalized DMC target is

$\xi = \{\exists t \le T : X(t) \in F\}.$3

At each step, the standard DMC algorithm propagates a particle, computes

$\xi = \{\exists t \le T : X(t) \in F\}.$4

and samples integer offspring

$\xi = \{\exists t \le T : X(t) \in F\}.$5

which has mean $\xi = \{\exists t \le T : X(t) \in F\}.$6. The ticketed variant augments each particle with $\xi = \{\exists t \le T : X(t) \in F\}.$7. If $\xi = \{\exists t \le T : X(t) \in F\}.$8 the particle is killed; otherwise offspring are created and assigned new tickets. For the first offspring,

$\xi = \{\exists t \le T : X(t) \in F\}.$9

and for additional offspring,

$$p = \Pr(\xi) = \prod_{k=0}^{K-1} p_k, \qquad p_k = \Pr(\xi_{k+1}\mid \xi_k),$$0

In snapshot-restart terms, the propagated parent state $$p = \Pr(\xi) = \prod_{k=0}^{K-1} p_k, \qquad p_k = \Pr(\xi_{k+1}\mid \xi_k),$$1 together with the current ticket is the checkpoint, and splitting at $$p = \Pr(\xi) = \prod_{k=0}^{K-1} p_k, \qquad p_k = \Pr(\xi_{k+1}\mid \xi_k),$$2 restarts multiple descendants from that snapshot. The regional restriction is encoded by the ticket: a descendant survives only while later weight factors exceed its ticket. The paper proves a one-step identity implying global unbiasedness, and then proves that the TDMC estimator has uniformly lower variance than the DMC estimator,

$$p = \Pr(\xi) = \prod_{k=0}^{K-1} p_k, \qquad p_k = \Pr(\xi_{k+1}\mid \xi_k),$$3

with strict inequality for strictly positive $$p = \Pr(\xi) = \prod_{k=0}^{K-1} p_k, \qquad p_k = \Pr(\xi_{k+1}\mid \xi_k),$$4. Expected workload is unchanged:

$$p = \Pr(\xi) = \prod_{k=0}^{K-1} p_k, \qquad p_k = \Pr(\xi_{k+1}\mid \xi_k),$$5

The motivation is instability in naive DMC for small time steps. In regimes such as

$$p = \Pr(\xi) = \prod_{k=0}^{K-1} p_k, \qquad p_k = \Pr(\xi_{k+1}\mid \xi_k),$$6

split/kill probabilities are $$p = \Pr(\xi) = \prod_{k=0}^{K-1} p_k, \qquad p_k = \Pr(\xi_{k+1}\mid \xi_k),$$7, and iterating $$p = \Pr(\xi) = \prod_{k=0}^{K-1} p_k, \qquad p_k = \Pr(\xi_{k+1}\mid \xi_k),$$8 steps yields $$p = \Pr(\xi) = \prod_{k=0}^{K-1} p_k, \qquad p_k = \Pr(\xi_{k+1}\mid \xi_k),$$9. Ticketing suppresses this variance explosion while preserving the target expectation.

The numerical examples reinforce the restart interpretation. For a Lennard-Jones cluster rare-event problem, the paper reports accurate estimates with manageable workloads down to probabilities such as $\xi_k=\{\exists t \le T : X(t)\in L_k\}$0. In high-frequency Lorenz–63 data assimilation, TDMC with $\xi_k=\{\exists t \le T : X(t)\in L_k\}$1 particles and $\xi_k=\{\exists t \le T : X(t)\in L_k\}$2 reconstructs the hidden trajectory almost exactly, whereas a comparable DMC or residual-resampling filter degenerates rapidly. These results are specific to the reported experiments, but they support the broader point that restart-style constraints can reduce variance per unit work without changing the underlying target.

5. Deterministic checkpoint-resume in adaptive MCMC software

A different meaning of snapshot-restart appears in ParaMonte::Python and MatDRAM, where the objective is exact continuation of an interrupted Monte Carlo or MCMC simulation rather than rare-event branching (Shahmoradi et al., 2020, Kumbhare et al., 2020). In ParaMonte::Python, restart is enabled by default, and the samplers write checkpoint information to external files during the run. The snapshot includes PRNG state and seed information, the current chain state and log-density, DRAM stage or delayed-rejection context, adaptive-proposal parameters such as the covariance matrix $\xi_k=\{\exists t \le T : X(t)\in L_k\}$3 and scale factors, adaptation diagnostics including AdaptationMeasure values, counters and progress markers, and file-bookkeeping state needed to append to output without duplication. Given the same seed and output filename, the library guarantees deterministic “into-the-future” restart; in MPI-parallel execution, the same parallel mode and process count are required for bitwise-identical continuation.

ParaMonte writes three principal outputs per run: *_chain.txt, *_restart.txt, and *_report.txt. The compact human-readable ASCII chain is the default, binary is optional, and compact output reduces storage by $\xi_k=\{\exists t \le T : X(t)\in L_k\}$4–$\xi_k=\{\exists t \le T : X(t)\in L_k\}$5 versus verbose chain output. Restart is triggered simply by rerunning the same script with the same output filename and RNG seed, after which the sampler detects existing files and resumes automatically.

MatDRAM implements a closely related design for a serial DRAM sampler. It continuously builds a dedicated restart file, binary by default, and stores a compact chain that records only accepted states together with a repetition count SampleWeight, reducing I/O by $\xi_k=\{\exists t \le T : X(t)\in L_k\}$6–$\xi_k=\{\exists t \le T : X(t)\in L_k\}$7 on average. The restart file contains random-number-generator state, current position $\xi_k=\{\exists t \le T : X(t)\in L_k\}$8 and SampleLogFunc, proposal-covariance state $\xi_k=\{\exists t \le T : X(t)\in L_k\}$9, adaptation counters and metadata, delayed-rejection stage context, and stage-dependent scaling. Upon reuse of the same outputFileName and randomSeed, MatDRAM locates the previously sampled state count $\hat p_k=S_k/M$0 and resumes at iteration $\hat p_k=S_k/M$1. The intended result is a chain matching the uninterrupted run up to $\hat p_k=S_k/M$2 digits of precision.

These systems show that checkpointing has a second, orthogonal role in Monte Carlo methodology. Here the concern is neither variance reduction nor rare-event amplification, but preservation of the exact stochastic trajectory of an adaptive algorithm whose state includes not only the current sample $\hat p_k=S_k/M$3, but also proposal adaptation and delayed-rejection machinery. The saved state must therefore be richer than a conventional chain history. In MatDRAM, for example, exact continuation of DRAM requires the snapshot to preserve the proposal covariance

$\hat p_k=S_k/M$4

and the current delayed-rejection stage, because both affect the acceptance probability after restart.

6. Anytime Monte Carlo and interruption bias under wall-clock budgets

“Anytime Monte Carlo” addresses a distinct problem: when the computational budget is specified in real time rather than in algorithmic steps, naive interruption and restart can bias the returned state (Murray et al., 2016). Let $\hat p_k=S_k/M$5 be a Markov chain with invariant distribution $\hat p_k=S_k/M$6, and let the time required to compute a transition depend on the current state via a holding-time law $\hat p_k=S_k/M$7. With a wall-clock budget $\hat p_k=S_k/M$8, the number of completed transitions

$\hat p_k=S_k/M$9

is random, where $L_k = \{x \in X : g(x) \ge \ell_k\},$00 are cumulative arrival times. The returned state is then

$L_k = \{x \in X : g(x) \ge \ell_k\},$01

The paper represents computation as a semi-Markov jump process

$L_k = \{x \in X : g(x) \ge \ell_k\},$02

where $L_k = \{x \in X : g(x) \ge \ell_k\},$03 is the lag since the last jump. The stationary distribution of the joint process is

$L_k = \{x \in X : g(x) \ge \ell_k\},$04

and the marginal time-stationary law of the state is

$L_k = \{x \in X : g(x) \ge \ell_k\},$05

Thus states with larger mean compute times are overrepresented. The induced bias does not vanish as $L_k = \{x \in X : g(x) \ge \ell_k\},$06 for the final state observed at a wall-clock stopping time.

The correction is a multiple-chain construction. One runs $L_k = \{x \in X : g(x) \ge \ell_k\},$07 chains in a serial schedule, with exactly one chain actively simulated and the other $L_k = \{x \in X : g(x) \ge \ell_k\},$08 chains waiting. After each jump, the roles rotate. The stationary distribution of the joint process is

$L_k = \{x \in X : g(x) \ge \ell_k\},$09

The waiting chains are therefore marginally distributed according to $L_k = \{x \in X : g(x) \ge \ell_k\},$10, while only the currently simulated chain carries the length-biased marginal $L_k = \{x \in X : g(x) \ge \ell_k\},$11. At interruption, the statistically correct action is to return the waiting chains and discard the simulating chain.

This framework applies directly to snapshot-restart implementations. To resume correctly one must snapshot chain states, RNG state, the scheduling pointer, lag $L_k = \{x \in X : g(x) \ge \ell_k\},$12 or last arrival time, and any adaptive internal state. In SMC and SMC$L_k = \{x \in X : g(x) \ge \ell_k\},$13, the paper replaces a fixed number of MCMC move steps with a wall-clock budget $L_k = \{x \in X : g(x) \ge \ell_k\},$14 per stage, adds one extra chain per processor, and discards the extra chain at the end of each move window. If compute cost grows linearly with stage index, the suggested budget allocation is

$L_k = \{x \in X : g(x) \ge \ell_k\},$15

A large-scale implementation used four billion particles across a cluster of $L_k = \{x \in X : g(x) \ge \ell_k\},$16 GPUs on Amazon EC2. The reported effect was substantial reduction in idle waiting at synchronization points, while preserving posterior accuracy in SMC$L_k = \{x \in X : g(x) \ge \ell_k\},$17.

A common misconception is that any snapshot-and-resume mechanism is statistically neutral. The anytime framework shows otherwise: if compute time is state-dependent, naive interruption of a single chain and return of its current state yields the wrong marginal law even asymptotically. In this setting, the snapshot is necessary but not sufficient; the resume protocol and the rule for which chains may be returned are part of the estimator.

7. Stochastic weights, restart optimality, and methodological constraints

Snapshot-restart ideas also appear in pseudo-marginal Monte Carlo with noisy weights (Frenkel et al., 2016). The target distribution over $L_k = \{x \in X : g(x) \ge \ell_k\},$18 is proportional to an average weight $L_k = \{x \in X : g(x) \ge \ell_k\},$19, but only a positive unbiased estimator $L_k = \{x \in X : g(x) \ge \ell_k\},$20 driven by auxiliary randomness $L_k = \{x \in X : g(x) \ge \ell_k\},$21 is available. Exactness is recovered by enlarging the state space:

$L_k = \{x \in X : g(x) \ge \ell_k\},$22

and using the Metropolis–Hastings acceptance rule

$L_k = \{x \in X : g(x) \ge \ell_k\},$23

Here the snapshot must include the auxiliary randomness $L_k = \{x \in X : g(x) \ge \ell_k\},$24 itself. A restart that refreshes $L_k = \{x \in X : g(x) \ge \ell_k\},$25 at fixed $L_k = \{x \in X : g(x) \ge \ell_k\},$26 is a Gibbs update and leaves the invariant law unchanged; by contrast, recomputing $L_k = \{x \in X : g(x) \ge \ell_k\},$27 with fresh noise after a rejection without treating $L_k = \{x \in X : g(x) \ge \ell_k\},$28 as part of the state breaks detailed balance.

The same paper develops a multi-snapshot “cloud” construction in which a backbone state $L_k = \{x \in X : g(x) \ge \ell_k\},$29 carries a cloud of nearby points. Its Rosenbluth weight is

$L_k = \{x \in X : g(x) \ge \ell_k\},$30

and the backbone acceptance probability is

$L_k = \{x \in X : g(x) \ge \ell_k\},$31

Because the cloud randomness is part of the extended state, the method satisfies super-detailed balance and samples the average weight exactly. When noisy energy differences are Gaussian and state-independent, the Ceperley–Dewing penalty correction

$L_k = \{x \in X : g(x) \ge \ell_k\},$32

restores correctness for nonlinear noisy Boltzmann factors.

Theoretical restart analysis places further constraints on when and why restart helps. For Bernoulli-like first-passage processes with success and failure channels, the success probability under a general restart-time survival function $L_k = \{x \in X : g(x) \ge \ell_k\},$33 is

$L_k = \{x \in X : g(x) \ge \ell_k\},$34

For deterministic restart at time $L_k = \{x \in X : g(x) \ge \ell_k\},$35,

$L_k = \{x \in X : g(x) \ge \ell_k\},$36

and if an optimal deterministic threshold $L_k = \{x \in X : g(x) \ge \ell_k\},$37 exists, no stochastic restart schedule can exceed its success probability (Belan, 2017). This is directly relevant to snapshot-restart rare-event simulation: carefully chosen fixed restart thresholds can optimize not only runtime but also the probability of achieving the desired outcome rather than an alternative absorbing event.

A complementary theory gives universal performance bounds for mean completion time under restart (Starkov et al., 2022). For uncoupled restart strategies, periodic restart is universally optimal among deterministic and stochastic restart protocols. If $L_k = \{x \in X : g(x) \ge \ell_k\},$38 minimizes $L_k = \{x \in X : g(x) \ge \ell_k\},$39, then

$L_k = \{x \in X : g(x) \ge \ell_k\},$40

where $L_k = \{x \in X : g(x) \ge \ell_k\},$41 is the median completion time, while for any restart protocol $L_k = \{x \in X : g(x) \ge \ell_k\},$42,

$L_k = \{x \in X : g(x) \ge \ell_k\},$43

with harmonic mean $L_k = \{x \in X : g(x) \ge \ell_k\},$44, and for smooth unimodal $L_k = \{x \in X : g(x) \ge \ell_k\},$45 with mode $L_k = \{x \in X : g(x) \ge \ell_k\},$46,

$L_k = \{x \in X : g(x) \ge \ell_k\},$47

The same work gives sufficient conditions for beneficial restart:

$L_k = \{x \in X : g(x) \ge \ell_k\},$48

These results supply a high-level design rule for snapshot-restart policies: when restart is used to truncate long attempts and renew independent realizations, deterministic thresholds are theoretically preferred to uncoupled stochastic schedules.

Several methodological constraints recur across the literature. Independence between attempts is essential in restart theory (Belan, 2017, Starkov et al., 2022). In fixed-level SMC, only first-hitting checkpoints should be stored, fresh randomness must be used after every restart, and levels should remain policy-invariant for policy evaluation (López et al., 6 May 2026). In pseudo-marginal settings, the noise variables must be part of the state (Frenkel et al., 2016). In deterministic checkpoint-resume systems, the same seed, output filename, and, for MPI, the same parallel mode and number of ranks are required for exact continuation (Shahmoradi et al., 2020, Kumbhare et al., 2020). And in anytime Monte Carlo, the simulating chain must be discarded at interruption to avoid length bias (Murray et al., 2016).

Taken together, these results show that snapshot-restart mechanisms are not a single technique but a family of state-preserving constructions whose validity depends on what is being preserved and why. In rare-event SMC, snapshots localize simulation effort in critical regions; in RESTART/DPR-style DMC they control branching variance; in adaptive MCMC software they preserve the exact stochastic trajectory; in anytime Monte Carlo they make interruption compatible with correct marginals; and in pseudo-marginal sampling they carry the auxiliary randomness required for exactness. The unifying requirement is that the snapshot must encode precisely the state on which future law depends.