State-Dependency Graph: Theory & Applications
- State-Dependency Graph is a graph-theoretic construct where nodes represent states and edges encode dependencies via statistical, temporal, and causal relations.
- It underpins diverse applications from multivariate forecasting and dynamic state estimation in power systems to smart contract analysis and quantum state representations.
- Various methodologies fuse static and dynamic models to address challenges in identifiability, interpretability, and computational efficiency in estimating state dependencies.
Searching arXiv for recent and relevant papers on “state-dependency graph” and closely related formulations. arxiv_search(query="\"state-dependency graph\" OR \"state dependency graph\" OR \"graph state-space models\" OR \"Adaptive Dependency Learning Graph Neural Networks\"", max_results=10) arxiv_search(query="observability dynamic state estimation dependency graph power system arXiv", max_results=10) A state-dependency graph is a graph-theoretic representation in which nodes denote states, state variables, latent state nodes, outputs, or state-bearing execution steps, and edges encode how one element depends on another through statistical structure, state equations, measurement equations, temporal order, read/write relations, or reused results. The exact term varies across literatures—“dependency graph,” “state-dependency graph,” “structural graph,” “state graph,” and “SDG” all appear—but the common function is to externalize state relations so that they can be forecast, propagated, tested for observability, queried for vulnerabilities, or interpreted as an entanglement structure (Sriramulu et al., 2023, Kandivalasa et al., 30 Oct 2025, Zambon et al., 2023, Liao et al., 2024, Zhao, 22 Jun 2026, Liao et al., 2021).
1. Formal scope and representations
The most generic form is a graph . In multivariate forecasting, nodes correspond to time series and the adjacency matrix satisfies
so the graph “encodes dependencies among states (series) at a given time” (Sriramulu et al., 2023). In dynamic state estimation, the same idea is made structural: a directed edge exists if the state derivative or update of depends directly on , and an edge exists if measurement depends on state (Kandivalasa et al., 30 Oct 2025). In smart-contract analysis, the SDG is explicitly defined as
with and edge labels in 0 (Liao et al., 2024). In agent-execution analysis, a run is represented as
1
with execution and dependency layers on the same node set, and with each dependency edge graded as observed, declared, or inferred (Zhao, 22 Jun 2026).
| Context | Nodes | Dependency relation |
|---|---|---|
| Multivariate forecasting | series or latent state nodes | correlation, Granger causality, mutual information, transfer entropy, sampled latent edges |
| Dynamic/state estimation | state variables, outputs, buses | state-to-state and output-to-state dependencies, measurement couplings |
| Smart contracts and agents | basic blocks, state variables, decisions, tools, resources | control-flow, read/write, assertion-related, temporal, execution, reliance |
| Quantum graph states | qubits | adjacency-induced phase dependencies |
These variants differ in ontology but not in purpose. In every case, the graph is the data structure that makes state interaction explicit. This suggests that “state-dependency graph” is best treated as a family resemblance term rather than as a single canonical object.
2. Time-varying and latent state-dependency graphs in dynamical modeling
In multivariate time series forecasting, the state is often the vector 2 of all variables at time 3, with 4 and forecasting defined as prediction of 5 (Sriramulu et al., 2023). “Adaptive Dependency Learning Graph Neural Networks” constructs an initial static adjacency from multiple pairwise dependency matrices: correlation, Granger causality, correlation spanning tree, graphical lasso, maximum likelihood estimation, mutual information, and transfer entropy. These are fused by
6
followed by top-7 sparsification per node. The resulting graph is then made dynamic by sparse convolutional attention restricted by a binary mask derived from the static graph. The paper states that this produces an 8 sparse dynamic weight matrix and that “these weights determine the strength of dependency of a series over the other,” after which the weights are summed with the static adjacency to construct a dynamic adjacency matrix. The graph convolution module then propagates information with
9
so the time-varying adjacency directly controls inter-series information flow (Sriramulu et al., 2023).
A more explicitly latent formulation appears in “Graph state-space models,” where the core object is a time-indexed state graph 0 rather than a fixed observed graph. Inputs, states, and outputs are graph-valued; the state transition is probabilistic,
1
and the graph is built through Select–Reduce–Connect. The edge set is sampled from
2
with a Binary Edge Sampler whose parameters form a matrix 3. Each entry 4 is interpreted as the probability that state node 5 depends on node 6 at time 7, after which message passing produces the final state graph 8 (Zambon et al., 2023). The paper is explicit that this is a functional dependency graph rather than a causal graph.
Directed-graph state-space modeling pushes the same idea toward path-dependent causality. “State Space Models over Directed Graphs” introduces DirEgo2Token, which forms for each node 9 a directed ego-sequence
0
where 1 contains nodes at directed shortest-path distance 2 from 3. Aggregated predecessor tokens are then processed by an SSM scan. The induced dependency structure is distance-aware, content-adaptive, and aligned with directed predecessor relations rather than with arbitrary node orderings. The paper characterizes this as the first systematic extension of state space models to directed graph learning, and reports state-of-the-art performance on three representative directed graph learning tasks with 4 to 5 training speed improvements compared to existing state-of-the-art models (She et al., 17 Sep 2025).
3. Structural observability and state estimation
In dynamic state estimation for power systems, the state-dependency graph is the central graph-theoretic object for observability analysis. The dynamical model is written in state-space form,
6
or, after linearization,
7
The graph is constructed from the sparsity pattern of 8 and 9, or of 0 and 1: 2 if 3 or 4, and 5 if 6 or 7 (Kandivalasa et al., 30 Oct 2025). Observability is then analyzed through strongly connected components (SCCs), the condensation DAG, root SCCs, and measurement reachability. The proposed method “provably executes in linear time with respect to the number of nodes and edges in a graph,” and in a centralized DSE setting reduced computation time by 8 relative to the numerical benchmark considered in the paper (Kandivalasa et al., 30 Oct 2025).
The same dependency logic appears in graph-based power-system state estimation, but there the graph is the physical network 9, with buses as vertices, lines as edges, and measurements stored as vertex or edge attributes. The system state is the vector of bus voltage magnitudes and angles. Bus injections depend on a bus and its 0-step neighbors, line flows depend on the two terminal buses and the line, and the Jacobian and gain matrix inherit this locality. The node-based decomposition is
1
with a similar decomposition for the right-hand side (Yuan et al., 2018). Each vertex computes its local 2, 3, and residual contribution using only local and neighboring information, after which global assembly proceeds in CSR form and hierarchical parallel computation. The paper reports total time of about 4 ms for the IEEE 118-bus system and about 5 ms for the FJ-1425 system on the stated platform (Yuan et al., 2018).
These two lines of work differ in target—structural observability in one case, weighted least squares estimation in the other—but both treat state-dependency as a sparsity structure that determines what can be inferred and how efficiently it can be computed.
4. Program state, execution state, and cross-transaction dependency
In smart-contract analysis, the state-dependency graph is explicitly programmatic. SmartState defines the SDG as
6
where 7 contains state-variable nodes and basic-block nodes, and edge labels are 8, 9, 0, and 1 (Liao et al., 2024). Read/write edges connect state variables to blocks that read or write them; assertion-related state dependency (ASD) links a function that reads a state variable inside require, assert, or revert to another function that writes that variable; temporal-ordered state dependency (TSD) is inferred from a finite state machine constructed from historical transaction traces. The framework then detects two generic SRV indicators:
2
and
3
The evaluation reports a precision of 4 and a recall of 5, and states that SmartState identified 6 new SRVs from 7 real-world smart contracts (Liao et al., 2024).
GRADE generalizes state dependency from programs to LLM-agent runs. A run is modeled as a typed, temporal multigraph
8
where 9 are execution edges, 0 are dependency edges, and 1 grades each dependency edge as observed, declared, or inferred (Zhao, 22 Jun 2026). Resource nodes make state explicit: they represent “the external state being read or written, such as a database row, a file version, a web page, or other environment state.” Dependency edges satisfy 2 and mean that step 3 relied on the state produced or held by node 4. Under the weakest inference assumption, full history 5, the dependency layer saturates:
6
and the saturation ratio is
7
Across six corpora of LLM agents, the paper reports that the dependency layer can predict failure where run size is weak, that under leave-one-corpus-out transfer it stays above chance on every held-out class while run size fails, and that the execution layer localizes the faulting step in a failed multi-agent run (Zhao, 22 Jun 2026).
Both frameworks are state-centric extensions of control-flow analysis. SmartState adds persistent state, assertion semantics, and transaction order to bytecode-level dependence. GRADE adds explicit resource nodes and a graded epistemology of dependence to raw traces.
5. Sequential and specialized constructions
In dependency parsing, the state-dependency graph is not only analyzed but incrementally generated. The “Sequential Graph Dependency Parser” builds a graph 8 over sentence tokens and a root symbol, with
9
The parser state is explicitly defined as
0
and the policy over possible edges is 1 (Welleck et al., 2019). At each time step, the model updates a recurrent state, accumulates a global score matrix, and applies a valid decoder that masks out self-loops, duplicate edges, multiple heads, root in-edges, and cycles. The target edge set is treated as a set rather than a sequence, so training uses a set-based oracle over free edges rather than a fixed linearization. This makes the graph state-dependent in a literal sense: the partial graph constrains future legal actions, while the recurrent state summarizes past graph decisions.
In quantum information, the term is used in a different but structurally exact way. A graph state on 2 qubits has stabilizer standard form
3
where 4 is the adjacency matrix of the graph (Liao et al., 2021). The adjacency matrix is simultaneously a phase-dependency structure because the graph state can be written as
5
“Graph state representation of the toric code” shows that the toric-code graph decomposes into star graphs and half graphs. Star graphs encode Greenberger-Horne-Zeilinger states, half graphs encode nested bipartite phase dependencies, and “the topological order is identified with the existence of multiple star graphs” (Liao et al., 2021). The graph structure also yields a log-depth quantum circuit for state preparation, reducible to constant depth including ancillae and measurements at the cost of increasing circuit width.
These examples broaden the term beyond numerical state estimation. In parsing, a state-dependency graph is an evolving partial dependency tree controlled by a recurrent policy. In quantum stabilizer theory, it is an adjacency matrix whose pairwise edges encode the phase dependencies of a many-body state.
6. Semantics, interpretability, and recurring limitations
Several works explicitly qualify the semantics of their graphs. In adaptive dependency learning for forecasting, the fused adjacency mixes correlation, mutual information, graphical lasso, Granger causality, transfer entropy, and maximum-likelihood couplings, so the result is “best described as a hybrid dependency graph with causal semantics, not a formally identified causal DAG” (Sriramulu et al., 2023). In graph state-space models, the learned state graph is also not constrained to be acyclic; the paper states that there is “no explicit causal constraint” and treats the graph as a functional dependency graph (Zambon et al., 2023). This suggests that, outside structural systems theory, “dependency” is often stronger than mere correlation but weaker than identified causality.
A second recurring issue is identifiability. Graph state-space models note that multiple different graphs can explain the data equally well, so identifiability of the true underlying graph is not guaranteed (Zambon et al., 2023). Adaptive dependency learning uses pairwise structure learning methods, estimates the static graph from only the latest 6 of training data for efficiency, and does not directly regularize the graph through a separate end-to-end graph loss (Sriramulu et al., 2023). These design choices favor predictive performance over unique structural recovery.
A third issue is the distinction between structural and numerical properties. In graph-based observability for power-system DSE, structural observability is a generic property of the sparsity pattern, and the paper explicitly notes that pathological parameter choices can still yield numerical unobservability (Kandivalasa et al., 30 Oct 2025). SmartState similarly distinguishes graph construction from front-end recovery: CFG, R/W, and ASD depend on bytecode decompilation, and TSD depends on the diversity of transaction history, so incompleteness in program logic recovery or in traces can propagate into the SDG (Liao et al., 2024).
Finally, some works treat the provenance of edges as part of the object itself. GRADE’s grading of dependency edges as observed, declared, or inferred is an explicit acknowledgment that not all dependencies have the same evidentiary status. Under full-history inference, the dependency layer collapses to a deterministic function of run size, and the paper argues that generic GNNs may misread this degenerate regime because they have “no channel for attachment grade 7” (Zhao, 22 Jun 2026). This is a sharp reminder that a state-dependency graph is not only a structural object but also an epistemic one: what counts as a dependency, and how reliably it is known, can be as important as the topology itself.
Across the surveyed literatures, state-dependency graphs therefore range from static sparsity patterns to dynamically updated weighted graphs, from latent stochastic state graphs to typed execution-and-resource multigraphs, and from parser configurations to graph-state adjacencies. The unifying idea is stable: state is represented as a set of graph vertices, and dependency is made explicit as a graph relation that can be propagated, queried, optimized, or interpreted.