Simulatable Processes Overview

• Simulatable processes are models with explicit state representations and operational semantics that enable step-by-step execution preserving intended behaviors.
• They span diverse fields, including quantum circuits, business process simulation, and physical modeling, by employing structured representations and control-flow mechanisms.
• They utilize constructive simulation procedures and fidelity metrics to bridge theoretical abstractions with practical, scalable execution.

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 (Ermakov et al., 2024, Binder et al., 2017, Barros, 2023, Pourbafrani et al., 2022, Foster et al., 2021, Quigley et al., 2018, Zhong et al., 13 Sep 2025, Levy et al., 20 Jun 2026).

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 (Ermakov et al., 2024, Binder et al., 2017, Barros, 2023, Pourbafrani et al., 2022, Avramenko et al., 9 Sep 2025, Quigley et al., 2018, Zhong et al., 13 Sep 2025, Levy et al., 20 Jun 2026).

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 (Ermakov et al., 2024, Binder et al., 2017, Barros, 2023, Avramenko et al., 9 Sep 2025, Foster et al., 2021).

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 (Barros, 2023, Pourbafrani et al., 2021, Levy et al., 20 Jun 2026, Foster et al., 2021).

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 (Lunemann et al., 2011, Pourbafrani et al., 2022, Avramenko et al., 9 Sep 2025, Quigley et al., 2018, Zhong et al., 13 Sep 2025, Chen et al., 28 Jul 2025).

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" (Ermakov et al., 2024), 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" (Binder et al., 2017), 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 $\Xi_{\tau_{st}}$0, and a single fixed unitary $\Xi_{\tau_{st}}$1 satisfies

$\Xi_{\tau_{st}}$2

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" (Barros, 2023), a HyFlow base model is given as

$\Xi_{\tau_{st}}$3

and each process $\Xi_{\tau_{st}}$4 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" (Pourbafrani et al., 2022) and "SIMPT: Process Improvement Using Interactive Simulation of Time-aware Process Trees" (Pourbafrani et al., 2021) 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" (Avramenko et al., 9 Sep 2025) uses a workflow graph

$\Xi_{\tau_{st}}$5

inside a business-process simulation model

$\Xi_{\tau_{st}}$6

and reconstructs the current system state as

$\Xi_{\tau_{st}}$7

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" (Foster et al., 2021), the core codatatype is

$\Xi_{\tau_{st}}$8

which supports termination, internal activity, and visible interaction in a single executable object. Circus actions are then homogeneous KTrees of type $\Xi_{\tau_{st}}$9, 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 $N(), \Omega(t), \Delta(t,x)$0. The resulting computational cost tracks the number of significant operators and thereby ties executable simulation directly to operator-space complexity (Ermakov et al., 2024).

The q-simulator construction for finite-state stochastic processes is equally explicit. One first defines overlaps

$N(), \Omega(t), \Delta(t,x)$1

realizes the corresponding Gram matrix as vectors $N(), \Omega(t), \Delta(t,x)$2, and then completes the partially specified action of $N(), \Omega(t), \Delta(t,x)$3 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 (Binder et al., 2017).

Hybrid and process-interaction models emphasize scheduler-level execution. HyFlow defines base components $N(), \Omega(t), \Delta(t,x)$4 and process simulators $N(), \Omega(t), \Delta(t,x)$5. 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 $N(), \Omega(t), \Delta(t,x)$6. Dynamic process creation and destruction are encoded through changes in $N(), \Omega(t), \Delta(t,x)$7, so a changing process population remains simulatable within the same semantics (Barros, 2023).

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 (Pourbafrani et al., 2021). CoSMo instead learns a conditioned recurrent simulation model of the form

$N(), \Omega(t), \Delta(t,x)$8

so that event-log generation is conditioned on a constraint vector $N(), \Omega(t), \Delta(t,x)$9 derived from DECLARE/LTL$\{B_k\}_{k=1}^{4^N}$0 rules (Oyamada et al., 2023). "Discovering Business Process Simulation Models in the Presence of Multitasking" (Estrada-Torres et al., 2020) keeps a classical one-task-at-a-time discrete-event simulator, but preprocesses logs with overlapping intervals into a coalesced log $\{B_k\}_{k=1}^{4^N}$1 whose adjusted durations encode multitasking behavior. "AgentSimulator" (Kirchdorfer et al., 2024) constructs a multi-agent system

$\{B_k\}_{k=1}^{4^N}$2

from an event log and then simulates the process by agent-local decisions, schedules, capabilities, and handover patterns. "What's Coming Next?" (Avramenko et al., 9 Sep 2025) complements these by reconstructing the current marking and resource state from an ongoing-cases log and initializing the simulator directly from $\{B_k\}_{k=1}^{4^N}$3.

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 (Levy et al., 20 Jun 2026). 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 (Zhong et al., 13 Sep 2025). 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 (Quigley et al., 2018). Mass-Spring Net learns per-spring stiffness and damping from observed motion and then advances the resulting system by semi-implicit Euler: $\{B_k\}_{k=1}^{4^N}$4 so the learned model remains an explicit simulator rather than a black-box predictor (Chen et al., 28 Jul 2025).

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	$\{B_k\}_{k=1}^{4^N}$5	number of significant operators
Quantum stochastic processes	$\{B_k\}_{k=1}^{4^N}$6, $\{B_k\}_{k=1}^{4^N}$7	quantum statistical complexity and quantum topological complexity
Event-log comparison	$\{B_k\}_{k=1}^{4^N}$8, $\{B_k\}_{k=1}^{4^N}$9	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, $A = \sum_{k=1}^{4^N} \lambda_k B_k,$0 counts the basis operators whose amplitudes exceed $A = \sum_{k=1}^{4^N} \lambda_k B_k,$1, and efficient simulability corresponds to $A = \sum_{k=1}^{4^N} \lambda_k B_k,$2 scaling at most polynomially in $A = \sum_{k=1}^{4^N} \lambda_k B_k,$3 and $A = \sum_{k=1}^{4^N} \lambda_k B_k,$4 for fixed $A = \sum_{k=1}^{4^N} \lambda_k B_k,$5 (Ermakov et al., 2024). In finite-state stochastic-process simulation, $A = \sum_{k=1}^{4^N} \lambda_k B_k,$6 and $A = \sum_{k=1}^{4^N} \lambda_k B_k,$7 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 (Binder et al., 2017).

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 (Pourbafrani et al., 2022). 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 (Avramenko et al., 9 Sep 2025). 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 $A = \sum_{k=1}^{4^N} \lambda_k B_k,$8 of the relevant semantic elements of the videos are present in the generated scenarios (Levy et al., 20 Jun 2026).

Physical simulability is often enforced before it is measured. InternScenes defines a physics-aware layout loss

$A = \sum_{k=1}^{4^N} \lambda_k B_k,$9

combining collision avoidance, grounding, and regularization toward the original layout, and then resolves remaining object interactions by physical simulation (Zhong et al., 13 Sep 2025). In the cloth setting, Mass-Spring Net trains against a force-and-impulse objective,

$\Omega^{(l)}$0

so that the learned model is judged by dynamical agreement rather than by position prediction alone (Chen et al., 28 Jul 2025).

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 (Ermakov et al., 2024). Second, classical stochastic processes with finite causal-state sets are quantumly simulatable by a unitary device with memory states $\Omega^{(l)}$1, a fixed unitary $\Omega^{(l)}$2, and entropic memory cost $\Omega^{(l)}$3 (Binder et al., 2017). 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 (Lunemann et al., 2011).

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 (Barros, 2023). 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 (Pourbafrani et al., 2021, Pourbafrani et al., 2022). CoSMo learns conditioned process simulation models from traces and declarative constraints, making it possible to generate event logs under a modified constraint vector $\Omega^{(l)}$4 (Oyamada et al., 2023). The multitasking-discovery approach preprocesses logs so that a standard non-multitasking simulator remains faithful to observed multitasking behavior (Estrada-Torres et al., 2020). AgentSimulator shifts the emphasis from global control-flow to resource-first multi-agent behavior discovered from an event log (Kirchdorfer et al., 2024). 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 (Avramenko et al., 9 Sep 2025).

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 (Quigley et al., 2018). 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 (Chen et al., 28 Jul 2025). 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 (Zhong et al., 13 Sep 2025). 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 (Levy et al., 20 Jun 2026).

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 (Foster et al., 2021). 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^{(l)}$5 diagonal and eliminates operator spreading, but computing that basis is generally as hard as the original many-body problem (Ermakov et al., 2024). 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 (Binder et al., 2017).

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 (Barros, 2023). 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 (Pourbafrani et al., 2022, Pourbafrani et al., 2021). 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” (Avramenko et al., 9 Sep 2025).

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 (Estrada-Torres et al., 2020). 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 (Kirchdorfer et al., 2024).

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 (Quigley et al., 2018). 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 (Chen et al., 28 Jul 2025). 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 (Zhong et al., 13 Sep 2025). 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 (Levy et al., 20 Jun 2026).

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.