---
title: State-Operation Paradigm Overview
url: https://www.emergentmind.com/topics/state-operation-paradigm
type: topic
---

# State-Operation Paradigm Overview

The state–operation paradigm denotes a family of formalisms in which a system is described through states together with operations, transformations, events, or predicates that act on those states or connect them. In the cited literature, the phrase has domain-specific realizations rather than a single universal definition: in quantum information it appears in stators, measurement-based computation, and operational dilations; in protocol analysis and storage systems it appears as explicit state-transition or state-observation constraints; in language-agent control and dialogue systems it appears as a decomposition of behavior into state construction and operation selection [1607.08122; 1002.4272; 1412.8539; 1404.3899; 1609.06670; 2605.12755; 2010.14061]. A recurring feature is that the formalism makes the relation between “what the system is” and “what is done to it” mathematically explicit.

## 1. Formal scope and recurring mathematical structure

One explicit definition appears in the State-Centric Decision Process, where an SOP is exactly an MDP specified by five objects: a state space $S$, an action set $A$, a transition function $T:S\times A\to S$, an observation mapping $\phi:\mathrm{Observations}\to S$, and a termination predicate $\mathrm{Done}\subseteq S$ [2605.12755]. In that formulation, the next state is $s' = T(s,a)$, and the paradigm is understood as the recovery of these objects in environments that emit raw text rather than pre-defined states.

A different but structurally related formalization appears in stateful protocol analysis. There, the state space is a set $S$ of global states, the operations form a set $\mathrm{Op}$ of state-operation symbols, and the transition relation is a subset
$$
\Delta \subseteq S \times \mathrm{Op} \times S.
$$
A triple $(s_0,\mathrm{op},s_1)\in\Delta$ means that when the global state is $s_0$, performing operation $\mathrm{op}$ yields state $s_1$ [1404.3899]. This form makes operations primitive and treats state evolution as constrained reachability.

A third formalization, in the “thinging machine” semantics, defines a state not as a snapshot of variables but as a *change* within a larger static diagram. A thimac is a pair $A=(M,T)$, the static model $S$ is an atemporal graph, and a TM-state is a change $\Delta\subseteq S$. Events are timed occurrences $E=(\Delta,[t_{\mathrm{start}},t_{\mathrm{end}}])$ [2007.07138]. This shifts the paradigm from “state as configuration” to “state as a coherent slice of process structure.”

These formulations do not identify a single shared ontology, but they do share a common discipline: states are represented explicitly, operations are formal objects rather than informal labels, and admissible evolutions are expressed through mappings, relations, or compatibility conditions.

## 2. Quantum realizations: stators, resource states, and remote operations

In quantum information, the most literal “state–operation” object is the stator. For two quantum systems $A$ and $B$ with Hilbert spaces $\mathcal H_A$ and $\mathcal H_B$, a stator is an element of $O(\mathcal H_A)\times \mathcal H_B$ generated by a joint unitary $U_{AB}$ and a reference state $|0_B\rangle$ through
$$
S = U_{AB}|0_B\rangle.
$$
It can be viewed as a map $S:\mathcal H_A\to \mathcal H_A\otimes\mathcal H_B$, or equivalently as an object in $O(\mathcal H_A)\otimes\mathcal H_B$ with canonical decomposition
$$
S=\sum_i M_i\otimes |i_B\rangle,
$$
where $M_i \equiv \langle i_B|U_{AB}|0_B\rangle$ are Kraus operators [1607.08122]. This is the “half-state, half-operator” formulation: $M_i$ is the half-operator on $A$, and $|i_B\rangle$ is the half-state on $B$.

The central feature is the eigenoperator relation
$$
\Theta_B\,S = S\,\Theta_A.
$$
If Hermitian Hamiltonians $H_A$ and $H_B$ satisfy $H_BS=SH_A$, then
$$
e^{-iH_B t}S = S e^{-iH_A t},
$$
so acting only on $B$ induces the corresponding dynamics on $A$ [1607.08122]. The qubit example
$$
S=\frac{1}{\sqrt 2}\bigl(1_A\otimes|\uparrow_B\rangle+\sigma_A\otimes|\downarrow_B\rangle\bigr)
$$
satisfies
$$
\sigma_{x,B}S = S\sigma_A,
$$
showing explicitly how an operator on $B$ induces the same operator on $A$. The same paper generalizes the construction to finite or compact groups through a group-element basis $|g\rangle$, Wigner matrices $D^j_{mn}(g)$, and the group element stator
$$
S=\int_G dg\,|g_A\rangle\langle g_A|\otimes |g_B\rangle,
$$
which obeys
$$
(U^j_{mn})_B S = S (U^j_{mn})_A.
$$
This group-theoretic form is then used for digital quantum simulation, where multi-body interactions are assembled from successive two-body stator couplings with a single ancilla [1607.08122].

Measurement-based quantum computation realizes a related separation between resource state and online operation. In the one-way model, a large entangled cluster state is prepared off-line once, and logical operations are then effected by choosing appropriate local measurement bases and applying classical feed-forward of the results [1002.4272]. In the continuous-variable four-partite cluster-state scheme, the overall action is equivalent to the two-mode unitary
$$
\hat U_{C_x} = \exp[-i\,\hat x_c\otimes \hat p_t],
$$
which implements the CV analog of a CNOT gate in the Heisenberg picture through the transformations $\hat x_t\to \hat x_t+\hat x_c$ and $\hat p_c\to \hat p_c-\hat p_t$ [1002.4272]. The online stage applies no further dynamic two-mode gates; the logical operation is specified by which cluster modes are measured, which quadrature bases are used, and how the outcomes are fed forward.

A controlled remote implementation protocol via graph states extends the stator idea to distributed control. Sharing a $(2N+1)$-partite graph state, $2N$ participants collaborate to prepare a multipartite stator and realize
$$
U=\bigotimes_{j=1}^N e^{\,i\alpha_j\sigma_{n_{O_j}}}
$$
on $N$ unknown remote states using only local operations and classical communication, with a controller’s permission [2210.14674]. The protocol’s eigenoperator relation again mediates the remote action, and the entanglement cost, measured by the geometric measure, is $N$ for the graph state $|G_{2N+1}\rangle$.

Taken together, these quantum formulations make the paradigm unusually concrete: an operation can be embedded into an entangled state, deferred into a measurement pattern, or recovered from a controlled resource state.

## 3. State–operation duality in operational and algebraic quantum theories

Operational-probabilistic theories formulate the paradigm categorically. Systems are objects of a strict symmetric monoidal category $\mathbf T$, transformations are morphisms $f:A\to B$, states are morphisms $\rho:I\to A$, effects are morphisms $a:A\to I$, and tests are finite families of transformations [1412.8539]. Within this framework, the Choi–Jamiolkowski correspondence appears as a state–operation duality: with a faithful state and purification, a transformation $\mathcal M:A\to B$ is mapped injectively to a state
$$
\Phi_{\mathcal M} := (\mathcal M\otimes \mathrm{id}_{A'})\circ \Phi.
$$
The purification principle states that every state $\rho:I\to A$ admits a pure dilation $\Psi:I\to A\otimes B$ with $\operatorname{tr}_B\Psi=\rho$, unique up to a reversible transformation on the auxiliary system. Under the same hypotheses, every transformation $\mathcal M:A\to B$ admits a pure dilation
$$
\mathcal P:A\to B\otimes E,\qquad \operatorname{tr}_E\circ \mathcal P = \mathcal M,
$$
which is the operational analogue of Stinespring’s theorem [1412.8539].

Hardy’s circuit framework gives a different operational structure. A theory is built from operations, wires, fragments, and circuits without assuming a background time. Hypersurfaces foliating the circuit define a graphical notion of “passing through” operations. States are compressed vectors $\mathbf p^\alpha_a\in\mathbb R^{K_a}$ for preparations, effects are vectors $\mathbf r^\beta_a$, and transformations are matrices
$$
{}^b\!Z_a^\beta:\mathbb R^{K_a}\to\mathbb R^{K_b}
$$
such that
$$
\mathbf p_b^{\alpha\beta} = {}^b\!Z_a^\beta\,\mathbf p_a^\alpha,\qquad
p^{\alpha\beta\gamma} = (\mathbf r^\gamma_b)^T\,{}^b\!Z_a^\beta\,\mathbf p_a^\alpha.
$$
For locally tomographic theories, circuit probabilities can be computed from matrices associated with the operations, classical theory and complex quantum theory appear as examples, and quaternionic quantum theory is excluded by the inequality conflict described in the paper [0912.4740].

An operator-algebraic version appears in the “props and ops” model. There the $C^*$-algebra $A$ of observables is the syntax, a quantum state is a linear functional $\rho:A\to\mathbb C$ satisfying positivity and normalization, and operations are completely positive unital maps
$$
\mathcal E(A)=\sum_k E_k^* A E_k,\qquad \sum_k E_k^*E_k=I.
$$
The GNS construction recovers a Hilbert-space representation from $\rho$, measurement acts by the Lüders map
$$
\rho \longmapsto \rho_E(\,\cdot\,)=\frac{\rho(E\,\cdot\,E)}{\rho(E)},
$$
and the Knill–Laflamme conditions are written in the algebraic form
$$
P E_i^* E_j P = \lambda_{ij} P
$$
for a code projector $P$ [2509.04527]. Here the state–operation paradigm is neither a circuit schedule nor a remote-control mechanism; it is a syntax–semantics pairing in which observables and state functionals are dual primitives.

## 4. Stateful protocols and application-visible storage semantics

In security protocol analysis, the state–operation relation is used to integrate mutable state with message passing. For the Envelope Protocol, the TPM’s mutable long-term state is a single PCR register modeled as a sort $M$ generated by the constructors $bt$ and $ex(t,m)$. A coercion
$$
pcr:M\to S_{\mathrm{msg}}
$$
is defined by
$$
pcr(bt)=s_0,\qquad pcr(ex(t,m)) = \#(t,pcr(m)),
$$
and the transition relation $\,\to\,\subseteq M\times M$ includes boot, extend$(t)$, and state-preserving quote/decrypt steps [1404.3899]. CPSA models state-bearing tokens as encrypted messages, while PVS develops a theory of infinite state paths with $\forall i.\,\pi(i)\to\pi(i+1)$ and $\pi(0)=bt$. The joint theory introduces *compatibility*: a bundle is compatible with the transition system when its annotated nodes correspond bijectively to positions along a valid state path. The analysis then alternates between CPSA shape analysis and PVS bridge lemmas until contradiction or proof. In the Envelope Protocol case study, the method proves that Alice’s secret and the refusal-quote cannot both be exposed in any real execution [1404.3899].

A related but distinct use appears in storage semantics. The state-based model of consistency and isolation defines database states as
$$
\Sigma=\{\,s\mid s:K\to V\,\},
$$
with distinguished initial state $s_0:K\to\{\bot\}$, and transactions as totally ordered sequences of reads $r(k,v)$ and writes $w(k,v)$ [1609.06670]. Executions are total orders
$$
s_0 \xrightarrow{[t_1]} s_{t_1} \xrightarrow{[t_2]} \cdots \xrightarrow{[t_n]} s_{t_n},
$$
and reads are constrained by candidate-read states $RS_e(o)$. Isolation is specified by commit-tests such as
$$
C_{SER}(t,e)\equiv \exists s:\ s\in \bigcap_{o\in\Sigma_t} RS_e(o)\ \wedge\ s=s_p,
$$
$$
C_{SI}(t,e)\equiv \exists s:\ s\in \bigcap_{o\in\Sigma_t} RS_e(o)\ \wedge\ (\mathrm{diff}(s,s_p)\cap W_t=\varnothing),
$$
$$
C_{RC}(t,e)\equiv \forall o\in\Sigma_t:\ RS_e(o)\neq\varnothing,
$$
and session guarantees are expressed by local session-tests for Read-My-Writes, Monotonic Reads, Monotonic Writes, Writes-Follow-Reads, and Causal Consistency [1609.06670]. The paper proves that the four session guarantees are equivalent to causal consistency, and that the recently proposed parallel snapshot isolation is a specific implementation of lazy consistency, or PL-2+.

Both literatures treat stateful behavior as something that cannot be reduced to unconstrained message histories or opaque operation logs. In one case the remedy is compatibility with a true state path; in the other it is to define guarantees directly as predicates over application-visible states.

## 5. Runtime construction and learned state operations

The State-Centric Decision Process applies the paradigm to language environments that emit raw text rather than explicit states. It introduces a runtime framework in which the agent constructs a task-induced state space, an observation-to-state mapping, certified transitions, and a termination criterion by committing to natural-language predicates and validating them against observations [2605.12755]. If $P$ is the universe of possible predicates, then the current certified state at time $t$ is
$$
s_t = \{\,p\in P : p\text{ is certified true by step }t\,\},
$$
and the observation mapping is
$$
\phi(o_t)=\{\,p\in P : \text{predicate }p\text{ passes on observation }o_t\,\}.
$$
Termination is defined by a designated goal predicate $g$ and occurs exactly when $g\in s_T$.

Because validation can certify multiple predicates at once, the transition function is written in cascade form: if the agent chooses action $a_t$ to realize a target predicate $\hat s_{t+1}$ and validation certifies $k\ge 1$ predicates, then
$$
s_{t+k}=T(s_t,a_t).
$$
The accompanying interfaces
- Propose: $(\mathrm{current\_state},\mathrm{goal})\to \mathrm{next\_predicate\_chain}$,
- Realize: $(\mathrm{current\_state},\mathrm{next\_predicate})\to \mathrm{action}$,
- Validate: $(\mathrm{pending\_predicates},\mathrm{observation})\to \mathrm{cascade\_count}$,
- Replan: $(\mathrm{current\_state},\mathrm{goal},\mathrm{trajectory})\to \mathrm{new\_subchain}$

make the pipeline modular, while the explicit predicate sequence enables per-predicate credit assignment, failure localization, partial-progress measurement, and modular operator replacement [2605.12755].

Open-vocabulary dialogue state tracking adopts a narrower but closely related decomposition. The dialogue state at turn $t$ is
$$
S_t = \{(d_j,s_j,v_j)\mid j=1\ldots J\},
$$
and for each slot the system first predicts a discrete state operation $o_j\in O$ and only generates a new value when $o_j=\mathrm{UPDATE}$ [2010.14061]. The four operations are CARRYOVER, DELETE, DONTCARE, and UPDATE. Transformer-DST uses a single BERT as both encoder and decoder, with a joint objective
$$
L(\theta)=L_{op}(\theta)+L_{gen}(\theta),
$$
so that operation prediction and value generation optimize the same parameter set. The state–operation paradigm here is not a state-transition system in the classical control sense; it is a decomposition of belief-state maintenance into discrete operational decisions plus conditional value generation.

These two machine-learning uses share a notable feature: the operational layer is explicit and interpretable. In SDP the state itself is built from validated predicates; in DST the update semantics of each slot is first classified before any generation occurs.

## 6. Interpretation, misconceptions, and limitations

Across these literatures, “state” does not denote a single ontological kind. In the stator formalism, the state–operation object is an entangled element of $O(\mathcal H_A)\otimes \mathcal H_B$; in database theory it is an application-visible mapping from keys to values; in TPM analysis it is a term-generated machine state; in TM semantics it is a change $\Delta\subseteq S$ cut from an atemporal static model; in SDP it is a growing set of certified predicates [1607.08122; 1609.06670; 1404.3899; 2007.07138; 2605.12755]. A plausible implication is that the paradigm is best understood structurally rather than lexically: what matters is not a uniform meaning of “state,” but the explicit formal relation between state and operation.

The same caution applies to “operation.” In quantum computation an operation may be induced remotely through an eigenoperator relation, or specified by local measurement bases and feed-forward on a fixed entangled resource [1607.08122; 1002.4272]. In protocol analysis it is a transition symbol such as boot or extend$(t)$; in TM semantics it is a time-tagged occurrence of a change; in dialogue state tracking it is a four-way per-slot label; in storage semantics it is a read or write constrained by commit-tests and session-tests [1404.3899; 2007.07138; 2010.14061; 1609.06670].

Several papers also identify characteristic limitations. TM semantics notes scalability, tool support, and learning curve as open challenges [2007.07138]. Transformer-DST reports slower inference than the RNN-stacked baseline because of full Transformer decoding [2010.14061]. CPSA’s state-passing style, taken alone, permits “splits” in imagined state histories that real state cannot exhibit, which is why the compatibility interface with PVS is required [1404.3899]. In language environments, the absence of explicit state space, observation-to-state mapping, certified transitions, and termination criterion is precisely the gap SDP is designed to fill [2605.12755].

A recurring misconception is that a state-based formalism merely rephrases an operation history. Several of the cited works argue the opposite. “Seeing is Believing” explicitly contrasts application-visible states with hidden operation histories and uses that shift to unify isolation and consistency guarantees [1609.06670]. The stator formalism embeds an operation into a joint entangled object rather than treating it as an ordinary gate sequence [1607.08122]. Operational-probabilistic and algebraic approaches derive transformations from state-based constructions such as purification, GNS, or Choi-type correspondences [1412.8539; 2509.04527].

In that sense, the state–operation paradigm is less a single theory than a recurrent research strategy: make states explicit, formalize operations as state-transforming or state-induced objects, and use that explicitness to recover compositionality, verifiability, or remote controllability in domains where informal histories or opaque interfaces are inadequate.

Source: https://www.emergentmind.com/topics/state-operation-paradigm