---
title: Simulatable Processes Overview
url: https://www.emergentmind.com/topics/simulatable-processes
type: topic
---

# Simulatable Processes Overview

Taken together, the cited literature uses “simulatable processes” for processes, models, or environments that have enough formal, statistical, operational, or geometric structure to be executed by a simulator while preserving the behaviors of interest. In quantum information this may mean constraining operator spreading or constructing a finite-dimensional unitary simulator; in hybrid and business-process modeling it means providing an operational semantics or a discrete-event model with explicit control-flow, timing, and resources; in formal methods it means an executable denotational semantics; and in graphics, robotics, and embodied AI it means producing geometry or scenes that a physics engine can load, constrain, and evolve [2401.08187] [1709.02375] [2310.19818] [2201.07755] [2105.05133] [1812.08849] [2509.10813] [2606.21993].

## 1. Definitional scope and recurring features

Across these works, simulatable processes are not defined by a single disciplinary formalism. Rather, the phrase is applied to entities as different as quantum circuits, stationary stochastic processes, hybrid communicating processes, business processes inferred from event logs, state-rich reactive programs, articulated botanical geometries, cloth surrogates, indoor scenes, and driving scenarios. What unifies them is the requirement that the underlying process be represented in a form that a simulator can step through unambiguously and that the resulting executions remain faithful to the intended semantics or observed behavior [2401.08187] [1709.02375] [2310.19818] [2201.07755] [2509.07747] [1812.08849] [2509.10813] [2606.21993].

A first recurring feature is an explicit representation of state and transitions. In the quantum-circuit setting, this state is the coefficient vector of an observable in an operator basis; in finite-state stochastic processes it is a memory state \(|\sigma_i\rangle\) associated with a causal state; in hybrid modeling it is the pair of private and shared p-states manipulated by process simulators; in short-term business-process simulation it is the reconstructed current state \(\Xi_{\tau_{st}}\) containing case markings, enabled flows, ongoing activities, enablement times, start times, and resources; and in Interaction Trees it is either a return value or an explicit state threaded through a homogeneous KTree [2401.08187] [1709.02375] [2310.19818] [2509.07747] [2105.05133].

A second recurring feature is executable semantics. HyFlow expresses this through the actions \(N(), \Omega(t), \Delta(t,x)\); SIMPT translates time-aware process trees into SimPy processes; D-V2S produces SCENIC programs that CARLA can execute; and the Isabelle/HOL framework generates Haskell simulations from ITrees. In each case, the process description is not merely declarative: it is formulated so that a scheduler, interpreter, or simulator can advance it step by step [2310.19818] [2108.02052] [2606.21993] [2105.05133].

A third recurring feature is fidelity under approximation or abstraction. In some works fidelity is logical or ideal-world fidelity, as in fully simulatable coin-flipping against quantum adversaries; in others it is statistical, as in event-log comparison and remaining-cycle-time forecasting; and in still others it is physical, as in collision-free indoor scenes, articulated tree models, or cloth surrogates that preserve observed motion. This suggests that simulatable processes are typically defined relative to a target notion of faithfulness rather than by executability alone [1102.0887] [2201.07755] [2509.07747] [1812.08849] [2509.10813] [2507.21288].

## 2. Formal representations that make processes simulatable

Several papers make simulability precise by fixing a representation in which evolution is simple enough to compute or execute. In "Unified framework for efficiently computable quantum circuits" [2401.08187], an observable is expanded in a complete orthonormal operator basis \(\{B_k\}_{k=1}^{4^N}\),
\[
A = \sum_{k=1}^{4^N} \lambda_k B_k,
\]
and each circuit layer induces a real matrix \(\Omega^{(l)}\) through
\[
B_k' = \sum_j \Omega^{(l)}_{jk} B_j.
\]
The process becomes a walk on the graph induced by \(|\Omega_{jk}|\), and efficient simulability is tied to whether the effectively explored operator space remains small.

In "A practical, unitary simulator for non-Markovian complex processes" [1709.02375], the relevant representation is the \(\varepsilon\)-machine of a stationary stochastic process with finite output alphabet and finite causal-state set. Each causal state \(s_i\) is encoded by a quantum memory state \(|\sigma_i\rangle\), and a single fixed unitary \(U\) satisfies
\[
U\,|\sigma_i\rangle|0\rangle = \sum_{x\in\mathcal{A}} \sqrt{P(x\mid i)}\,|\sigma_{\lambda(i,x)}\rangle|x\rangle.
\]
The process is simulatable because a finite-dimensional Hilbert space suffices throughout the evolution, while the simulator reproduces the exact output statistics of the original process.

In "piHyFlow Operational Semantics" [2310.19818], a HyFlow base model is given as
\[
M_B = (X, Y_B, P_B, P_{0,B}, \zeta, \Pi, \pi, \sigma, \{\Lambda_p\}),
\]
and each process \(\varpi\) inside the base model is a time-aware, guard-driven state machine. Simulatability is guaranteed by an operational semantics in terms of base components and process simulators, with explicit next-transition, output, and transition functions. The process representation therefore already contains the scheduling discipline needed for execution.

Business-process simulation papers use process-tree or workflow-graph representations. "Interactive Process Improvement using Simulation of Enriched Process Trees" [2201.07755] and "SIMPT: Process Improvement Using Interactive Simulation of Time-aware Process Trees" [2108.02052] rely on process trees with sequence, XOR, parallelism, and loop operators, then enrich them with routing probabilities, durations, capacities, resources, business hours, and related parameters. "What's Coming Next? Short-Term Simulation of Business Processes from Current State" [2509.07747] uses a workflow graph
\[
W = (start, sink, N, F, t)
\]
inside a business-process simulation model
\[
BPSM = (W, R, D, P, T, I),
\]
and reconstructs the current system state as
\[
\Xi_{\tau_{st}} = \{ (\phi, arr_{\phi}, F_\phi, A_\phi, en_\phi, st_\phi, res_\phi) \mid \phi \in \Phi \}.
\]
These structures are simulation-ready because they make control-flow, timing, and resource occupation explicit.

Formal verification papers go further by identifying the simulator with the denotational semantics. In "Formally Verified Simulations of State-Rich Processes using Interaction Trees in Isabelle/HOL" [2105.05133], the core codatatype is
\[
(\,'e,'r)\,\texttt{itree} = \Ret\,'r \mid \Sil\,(\,'e,'r)\,\texttt{itree} \mid \Vis\,('\!e \pfun (\,'e,'r)\,\texttt{itree}),
\]
which supports termination, internal activity, and visible interaction in a single executable object. Circus actions are then homogeneous KTrees of type \((\,'e,'s)\,\texttt{htree} = 's \Rightarrow (\,'e,'s)\,\texttt{itree}\), so state-rich processes become directly executable while remaining amenable to proof.

## 3. Construction and execution mechanisms

Once an appropriate representation is fixed, the literature typically supplies a constructive simulation procedure. In the operator-growth framework for quantum circuits, the key approximate Heisenberg simulator maintains a list of active basis operators and propagates them backward through circuit layers, pruning terms whose amplitudes fall below a threshold \(\epsilon\). The resulting computational cost tracks the number of significant operators and thereby ties executable simulation directly to operator-space complexity [2401.08187].

The q-simulator construction for finite-state stochastic processes is equally explicit. One first defines overlaps
\[
c_{ij} = \sum_{\overrightarrow{x_0}} \sqrt{P(\overrightarrow{x_0}\mid i)\,P(\overrightarrow{x_0}\mid j)},
\]
realizes the corresponding Gram matrix as vectors \(|\sigma_i\rangle\), and then completes the partially specified action of \(U\) to a full unitary. The simulator repeatedly applies this fixed unitary to the memory and a fresh symbol register, measures the symbol register, and continues with the collapsed memory state. The process therefore remains unitary except for output measurement, and the same device can generate arbitrarily long trajectories [1709.02375].

Hybrid and process-interaction models emphasize scheduler-level execution. HyFlow defines base components \(\mathcal{C}_B = (\seqv{v,p}, N, \Omega, \Delta)\) and process simulators \(\mathcal{S}_\varpi^B = (\seqv{v,(p,t_L)}, N, \Omega, V, K, \Delta, U)\). The coordinator repeatedly asks for the next transition time, computes outputs at that time, performs the scheduled and conditional transitions, and advances internal timestamps by \(t+\varepsilon\). Dynamic process creation and destruction are encoded through changes in \(\pi(P_B)\), so a changing process population remains simulatable within the same semantics [2310.19818].

Business-process work uses event logs as the source of executable models. SIMPT discovers a process tree, derives activity durations, arrival rates, activity capacities, resource assignments, business hours, handover information, process capacity, and interruptions from historical event data, and then executes the resulting model in SimPy [2108.02052]. CoSMo instead learns a conditioned recurrent simulation model of the form
\[
h_j = f(U x_j + W h_{j-1} + K \Phi), \qquad y_j = g(V h_j) + x_j,
\]
so that event-log generation is conditioned on a constraint vector \(\Phi\) derived from DECLARE/LTL\(_f\) rules [2303.17879]. "Discovering Business Process Simulation Models in the Presence of Multitasking" [2004.09138] keeps a classical one-task-at-a-time discrete-event simulator, but preprocesses logs with overlapping intervals into a coalesced log \(\mathcal{L}''\) whose adjusted durations encode multitasking behavior. "AgentSimulator" [2408.08571] constructs a multi-agent system
\[
m = (A, p), \qquad a = (t, s, c, b),
\]
from an event log and then simulates the process by agent-local decisions, schedules, capabilities, and handover patterns. "What's Coming Next?" [2509.07747] complements these by reconstructing the current marking and resource state from an ongoing-cases log and initializing the simulator directly from \(\Xi_{\tau_{st}}\).

Recent embodied and physical simulators follow an analogous two-step pattern: convert raw observations into a structured asset, then execute that asset in a simulator. D-V2S uses a Driving Record Analyzer to turn videos into natural-language descriptions and a Scenario Generator to turn those descriptions into SCENIC scripts executed in CARLA [2606.21993]. InternScenes builds real-to-sim replicas, extracts structured layouts from procedural and designer-created scenes, replaces a subset of assets with interactive PartNet-Mobility objects, and then resolves collisions by bounding-box optimization and physical simulation [2509.10813]. The botanical-tree reconstruction pipeline converts drone videos into point clouds, generalized cylinders, a contiguous skinned mesh, and finally an articulated rigid-body model suitable for wind simulation [1812.08849]. Mass-Spring Net learns per-spring stiffness and damping from observed motion and then advances the resulting system by semi-implicit Euler:
\[
\mathbf{M} (\dot{\mathbf{x}}_{j+1} - \dot{\mathbf{x}}_{j}) = \Delta t \,\left[\mathbf{f}_{\text{ext},j} + \mathbf{f}_{\text{springs}}(\mathbf{x}_j)\right], \qquad
\mathbf{x}_{j+1} = \mathbf{x}_{j} + \Delta t\, \dot{\mathbf{x}}_{j+1},
\]
so the learned model remains an explicit simulator rather than a black-box predictor [2507.21288].

## 4. Quantifying simulability

Different fields quantify simulability with different observables, but the common pattern is that the simulator is judged by a quantity that mediates accuracy, tractability, or physical plausibility.

| Domain | Quantity | Role |
|---|---|---|
| Quantum circuits | \(\mathcal{N}_\epsilon = \sum_{j=1}^{4^N} T_\epsilon(|\lambda_j^{(L)}|)\) | number of significant operators |
| Quantum stochastic processes | \(C_q = S(\rho)\), \(C_q^0 = \log_2(\mathrm{rank}(\rho))\) | quantum statistical complexity and quantum topological complexity |
| Event-log comparison | \(EMD(L_{\mathcal{A}}, L'_{\mathcal{A}})\), \(PS(seg,L) = (AvgTime(seg,L), Freq(seg,L))\) | stochastic conformance and performance spectrum |
| Short-term process forecasting | OCD, NGD, R-CTD | workload, control-flow, and remaining-cycle-time comparison |
| Video-to-scenario generation | SCS, HR, SP, E2E-SC | semantic coverage, hallucination, preservation, and end-to-end consistency |

In the operator-growth framework, \(\mathcal{N}_\epsilon\) counts the basis operators whose amplitudes exceed \(\epsilon\), and efficient simulability corresponds to \(\mathcal{N}_\epsilon\) scaling at most polynomially in \(N\) and \(L\) for fixed \(\epsilon\) [2401.08187]. In finite-state stochastic-process simulation, \(C_q\) and \(C_q^0\) quantify memory requirements, and the q-simulator is notable because it realizes the previously identified minimum quantum memory cost with a fixed finite-dimensional Hilbert space [1709.02375].

Event-log based process simulation evaluates fidelity by comparing synthetic and original logs. The enriched-process-tree framework uses Earth Mover’s Distance over trace distributions and the aggregated performance spectrum, and also tracks new and removed behaviors induced by a scenario change [2201.07755]. Short-term process simulation from current state compares methods by Ongoing Cases Difference, N-gram Distance, and Remaining Cycle Time Distance, and shows that initialization from the reconstructed current state can outperform warm-up-based long-term simulation, especially under concept drift or bursty performance patterns [2509.07747]. D-V2S evaluates the descriptive and executable stages separately and end to end through SCS, HR, SP, and E2E-SC; the overall result reported for the full pipeline is that roughly \(90\%\) of the relevant semantic elements of the videos are present in the generated scenarios [2606.21993].

Physical simulability is often enforced before it is measured. InternScenes defines a physics-aware layout loss
\[
\mathcal{L}= \lambda_{\mathrm{IoU}} \mathcal{L}_{\mathrm{IoU}} + \lambda_{\mathrm{ground}} \mathcal{L}_{\mathrm{ground}} + \lambda_{\mathrm{reg}} \mathcal{L}_{\mathrm{reg}},
\]
combining collision avoidance, grounding, and regularization toward the original layout, and then resolves remaining object interactions by physical simulation [2509.10813]. In the cloth setting, Mass-Spring Net trains against a force-and-impulse objective,
\[
L = \lambda_{\text{f}} L_{\text{f}} + \lambda_{\text{J}} L_{\text{J}} + \lambda_{\text{k neg.}} L_{\text{k neg.}} + \lambda_{\text{b neg.}} L_{\text{b neg.}},
\]
so that the learned model is judged by dynamical agreement rather than by position prediction alone [2507.21288].

## 5. Major domains of use

In quantum information, simulatable processes appear in at least three distinct senses. First, certain quantum circuits are efficiently classically simulatable because their Heisenberg evolution remains confined to a low-complexity operator manifold, as in Clifford circuits and nearest-neighbor matchgate circuits [2401.08187]. Second, classical stochastic processes with finite causal-state sets are quantumly simulatable by a unitary device with memory states \(|\sigma_i\rangle\), a fixed unitary \(U\), and entropic memory cost \(C_q\) [1709.02375]. Third, in quantum cryptography, “fully simulatable” coin-flipping denotes an ideal-world/real-world simulation guarantee against polynomial-size quantum adversaries on both sides; the resulting coin-flip protocol is then used as a primitive for quantum-secure zero-knowledge proofs of knowledge and two-party function evaluation [1102.0887].

In process systems and business-process management, the dominant concern is whether a discovered or specified process can be executed under explicit control-flow, timing, and resource assumptions. HyFlow extends the process-interaction worldview to communicating hybrid models with sampling, dense outputs, dynamic process creation and destruction, and a constructive operational semantics [2310.19818]. SIMPT and the enriched-process-tree framework turn event logs into executable time-aware process trees whose parameters can be changed interactively for what-if analysis [2108.02052] [2201.07755]. CoSMo learns conditioned process simulation models from traces and declarative constraints, making it possible to generate event logs under a modified constraint vector \(\Phi^s\) [2303.17879]. The multitasking-discovery approach preprocesses logs so that a standard non-multitasking simulator remains faithful to observed multitasking behavior [2004.09138]. AgentSimulator shifts the emphasis from global control-flow to resource-first multi-agent behavior discovered from an event log [2408.08571]. Short-term simulation from current state extends this line by showing that operational forecasting requires a state representation rich enough to encode the actual current marking and resource occupation [2509.07747].

Physical, geometric, and embodied domains use simulatable processes to bridge perception and mechanics. The botanical-tree pipeline reconstructs a connected, loop-free tree graph of generalized cylinders, then skins it into a contiguous mesh and articulated rigid-body model for wind-driven motion [1812.08849]. Mass-Spring Net learns a surrogate mass–spring system with spatially varying stiffness and damping, retaining interpretability and explicit time integration while approximating the effects of more complex material behavior [2507.21288]. InternScenes treats an indoor scene as simulatable only after it has been converted into watertight or convex-decomposed assets, collision-cleaned, grounded, and populated with interactive articulated objects [2509.10813]. D-V2S extends the same logic to traffic: a driving video becomes a SCENIC program and then a CARLA scenario, so that a recorded event becomes controllable, repeatable, and scalable [2606.21993].

Formal methods contribute a different but complementary perspective. Interaction Trees in Isabelle/HOL provide a single semantic domain in which CSP and Circus processes can be reasoned about algebraically, linked to failures–divergences semantics, and exported as verified executable simulations [2105.05133]. A plausible implication is that “simulatable” can denote not only empirical executability but also semantic coherence between proof theory and execution.

## 6. Limits, artifacts, and open problems

The literature also shows that simulability is often fragile and representation-dependent. In the operator-growth framework, the choice of basis matters strongly: in principle the eigen-operator basis of an effective Hamiltonian makes \(\Omega\) diagonal and eliminates operator spreading, but computing that basis is generally as hard as the original many-body problem [2401.08187]. In finite-state stochastic-process simulation, exact unitary simulators are proven only for stationary processes with finite causal-state sets and finite alphabets; processes with infinite causal-state sets, non-stationarity, or continuous alphabets remain outside the construction as given [1709.02375].

Hybrid and process-system semantics introduce their own hazards. HyFlow gives an operational semantics but does not provide formal proofs of determinism, termination of zero-time loops, or deadlock freedom; executable behavior therefore still depends on modeling discipline, ranking functions, and the absence of infinite conditional-transition cycles [2310.19818]. Business-process simulation inherits the usual vulnerabilities of process mining: event-log incompleteness, simplified distributional assumptions, stationarity assumptions, and model-precision gaps. The enriched-process-tree and SIMPT papers both note that discovered models may allow behavior not present in the log, and that parameter quality is limited by event-log quality and by the fit between mined control-flow and the actual process [2201.07755] [2108.02052]. Short-term forecasting from current state can outperform warm-up methods, but long extraneous delays that are not modeled explicitly may cause the reconstructed current state to trigger activities “too early” [2509.07747].

Resource-level realism remains a persistent challenge. The multitasking-discovery approach assumes that overlapping work by a resource can be represented by equal time-sharing and then absorbed into adjusted durations for a standard one-task-at-a-time simulator, while explicitly noting that prioritization, preemption costs, and cross-process multitasking are not modeled [2004.09138]. AgentSimulator improves resource heterogeneity and decentralized decision-making, yet still does not model multitasking, batching, or fatigue, and its frequentist behavior estimates can become data-hungry for sparse prefixes or rare agents [2408.08571].

Physical and embodied pipelines reveal a parallel set of limitations. The botanical-tree reconstruction remains partly manual, does not provide ground-truth mechanical validation, and often binds unresolved twigs and leaves to nearby cylinders instead of reconstructing them as independent articulated elements [1812.08849]. Mass-Spring Net is intentionally simple and efficient, but its expressiveness is bounded by a fixed mass–spring topology and by the extent to which training trajectories sufficiently excite the local material parameters [2507.21288]. InternScenes still requires manual annotation for region and instance structure, supports interactive objects for only a subset of assets, and does not guarantee the total absence of residual geometric artifacts even after optimization and simulation [2509.10813]. D-V2S can fail at SCENIC compilation because of undefined symbols, API hallucinations, function misuse, or geometric infeasibility, and it does not attempt exact trajectory reconstruction from video [2606.21993].

A broader synthesis follows from these limits. Simulatable processes are rarely “given” by raw data or syntax alone; they are usually produced by an additional layer of structure—an operator basis, a causal-state decomposition, an operational semantics, a process tree with parameters, a corrected current-state representation, a collision-cleaned scene graph, a generalized-cylinder skeleton, or a verified coinductive semantics. This suggests that future work will continue to revolve around the same question in different guises: which abstractions preserve the behaviors of interest while remaining executable, controllable, and analyzable at scale.

Source: https://www.emergentmind.com/topics/simulatable-processes