Papers
Topics
Authors
Recent
Search
2000 character limit reached

State-Dependency Graph: Theory & Applications

Updated 14 July 2026
  • 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 G=(V,E)G=(V,E). In multivariate forecasting, nodes correspond to time series and the adjacency matrix satisfies

A∈Rn×n,A[i,j]>0 if (vi,vj)∈E,  A[i,j]=0 otherwise,A \in \mathbb{R}^{n \times n}, \quad A[i,j] > 0 \text{ if } (v_i, v_j) \in E, \; A[i,j] = 0 \text{ otherwise},

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 xj→xix_j \to x_i exists if the state derivative or update of xix_i depends directly on xjx_j, and an edge xj→yℓx_j \to y_\ell exists if measurement yℓy_\ell depends on state xjx_j (Kandivalasa et al., 30 Oct 2025). In smart-contract analysis, the SDG is explicitly defined as

Gs=(Ns,Es,X),G_{s} = (N_{s}, E_{s}, X),

with Ns:={S∪B}N_s:=\{S\cup B\} and edge labels in A∈Rn×n,A[i,j]>0 if (vi,vj)∈E,  A[i,j]=0 otherwise,A \in \mathbb{R}^{n \times n}, \quad A[i,j] > 0 \text{ if } (v_i, v_j) \in E, \; A[i,j] = 0 \text{ otherwise},0 (Liao et al., 2024). In agent-execution analysis, a run is represented as

A∈Rn×n,A[i,j]>0 if (vi,vj)∈E,  A[i,j]=0 otherwise,A \in \mathbb{R}^{n \times n}, \quad A[i,j] > 0 \text{ if } (v_i, v_j) \in E, \; A[i,j] = 0 \text{ otherwise},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 A∈Rn×n,A[i,j]>0 if (vi,vj)∈E,  A[i,j]=0 otherwise,A \in \mathbb{R}^{n \times n}, \quad A[i,j] > 0 \text{ if } (v_i, v_j) \in E, \; A[i,j] = 0 \text{ otherwise},2 of all variables at time A∈Rn×n,A[i,j]>0 if (vi,vj)∈E,  A[i,j]=0 otherwise,A \in \mathbb{R}^{n \times n}, \quad A[i,j] > 0 \text{ if } (v_i, v_j) \in E, \; A[i,j] = 0 \text{ otherwise},3, with A∈Rn×n,A[i,j]>0 if (vi,vj)∈E,  A[i,j]=0 otherwise,A \in \mathbb{R}^{n \times n}, \quad A[i,j] > 0 \text{ if } (v_i, v_j) \in E, \; A[i,j] = 0 \text{ otherwise},4 and forecasting defined as prediction of A∈Rn×n,A[i,j]>0 if (vi,vj)∈E,  A[i,j]=0 otherwise,A \in \mathbb{R}^{n \times n}, \quad A[i,j] > 0 \text{ if } (v_i, v_j) \in E, \; A[i,j] = 0 \text{ otherwise},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

A∈Rn×n,A[i,j]>0 if (vi,vj)∈E,  A[i,j]=0 otherwise,A \in \mathbb{R}^{n \times n}, \quad A[i,j] > 0 \text{ if } (v_i, v_j) \in E, \; A[i,j] = 0 \text{ otherwise},6

followed by top-A∈Rn×n,A[i,j]>0 if (vi,vj)∈E,  A[i,j]=0 otherwise,A \in \mathbb{R}^{n \times n}, \quad A[i,j] > 0 \text{ if } (v_i, v_j) \in E, \; A[i,j] = 0 \text{ otherwise},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 A∈Rn×n,A[i,j]>0 if (vi,vj)∈E,  A[i,j]=0 otherwise,A \in \mathbb{R}^{n \times n}, \quad A[i,j] > 0 \text{ if } (v_i, v_j) \in E, \; A[i,j] = 0 \text{ otherwise},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

A∈Rn×n,A[i,j]>0 if (vi,vj)∈E,  A[i,j]=0 otherwise,A \in \mathbb{R}^{n \times n}, \quad A[i,j] > 0 \text{ if } (v_i, v_j) \in E, \; A[i,j] = 0 \text{ otherwise},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 xj→xix_j \to x_i0 rather than a fixed observed graph. Inputs, states, and outputs are graph-valued; the state transition is probabilistic,

xj→xix_j \to x_i1

and the graph is built through Select–Reduce–Connect. The edge set is sampled from

xj→xix_j \to x_i2

with a Binary Edge Sampler whose parameters form a matrix xj→xix_j \to x_i3. Each entry xj→xix_j \to x_i4 is interpreted as the probability that state node xj→xix_j \to x_i5 depends on node xj→xix_j \to x_i6 at time xj→xix_j \to x_i7, after which message passing produces the final state graph xj→xix_j \to x_i8 (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 xj→xix_j \to x_i9 a directed ego-sequence

xix_i0

where xix_i1 contains nodes at directed shortest-path distance xix_i2 from xix_i3. 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 xix_i4 to xix_i5 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,

xix_i6

or, after linearization,

xix_i7

The graph is constructed from the sparsity pattern of xix_i8 and xix_i9, or of xjx_j0 and xjx_j1: xjx_j2 if xjx_j3 or xjx_j4, and xjx_j5 if xjx_j6 or xjx_j7 (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 xjx_j8 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 xjx_j9, 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 xj→yℓx_j \to y_\ell0-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

xj→yℓx_j \to y_\ell1

with a similar decomposition for the right-hand side (Yuan et al., 2018). Each vertex computes its local xj→yℓx_j \to y_\ell2, xj→yℓx_j \to y_\ell3, 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 xj→yℓx_j \to y_\ell4 ms for the IEEE 118-bus system and about xj→yℓx_j \to y_\ell5 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

xj→yℓx_j \to y_\ell6

where xj→yℓx_j \to y_\ell7 contains state-variable nodes and basic-block nodes, and edge labels are xj→yℓx_j \to y_\ell8, xj→yℓx_j \to y_\ell9, yℓy_\ell0, and yℓy_\ell1 (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:

yℓy_\ell2

and

yℓy_\ell3

The evaluation reports a precision of yℓy_\ell4 and a recall of yℓy_\ell5, and states that SmartState identified yℓy_\ell6 new SRVs from yℓy_\ell7 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

yℓy_\ell8

where yℓy_\ell9 are execution edges, xjx_j0 are dependency edges, and xjx_j1 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 xjx_j2 and mean that step xjx_j3 relied on the state produced or held by node xjx_j4. Under the weakest inference assumption, full history xjx_j5, the dependency layer saturates:

xjx_j6

and the saturation ratio is

xjx_j7

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 xjx_j8 over sentence tokens and a root symbol, with

xjx_j9

The parser state is explicitly defined as

Gs=(Ns,Es,X),G_{s} = (N_{s}, E_{s}, X),0

and the policy over possible edges is Gs=(Ns,Es,X),G_{s} = (N_{s}, E_{s}, X),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 Gs=(Ns,Es,X),G_{s} = (N_{s}, E_{s}, X),2 qubits has stabilizer standard form

Gs=(Ns,Es,X),G_{s} = (N_{s}, E_{s}, X),3

where Gs=(Ns,Es,X),G_{s} = (N_{s}, E_{s}, X),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

Gs=(Ns,Es,X),G_{s} = (N_{s}, E_{s}, X),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 Gs=(Ns,Es,X),G_{s} = (N_{s}, E_{s}, X),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 Gs=(Ns,Es,X),G_{s} = (N_{s}, E_{s}, X),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.

Topic to Video (Beta)

No one has generated a video about this topic yet.

Whiteboard

No one has generated a whiteboard explanation for this topic yet.

Follow Topic

Get notified by email when new papers are published related to State-Dependency Graph.