Joint-State Graph (JSG) for Coordination

• Joint-State Graph (JSG) is a lifted graphical representation that models multi-agent coordination by formulating problems in a joint state space, enabling explicit support-action integration.
• It employs graph-based optimization and message passing to convert state-dependent and risky edge costs into standard shortest-path problems, using algorithms like Dijkstra and A*.
• Variants such as CJSG and Dynamic-HJSG reduce computational complexity through hierarchical and dynamic reductions while preserving optimality in both planning and inference tasks.

Searching arXiv for the specified paper and related "Joint-State Graph" usages to ground the article in current literature. Joint-State Graph (JSG) denotes a reformulation in which a multi-entity coordination or inference problem is lifted into a state space over tuples of local states, so that coupled decisions can be handled through graph-based optimization or message passing. In the multi-agent coordination literature, JSG is introduced as a planning problem in the joint state space, with joint states given by Cartesian products of agent locations and edge weights that implicitly encode support actions, thereby reducing a coordination problem with state-dependent edge costs to a standard single-agent shortest-path problem on the lifted graph (Oughourli et al., 2023). In a distinct usage in CSS syndrome decoding, the term refers to a binary factor-graph representation in which paired local variables $(x_i^X,x_i^Z)$ are coupled by a joint prior, and sum-product on that graph is termed joint belief propagation; in that setting, the “joint-state” construction preserves local channel correlation and is shown to be algebraically identical to four-state BP after relabeling and marginalization (Kasai, 6 May 2026). The term therefore names a general representational strategy rather than a single universally standardized object.

1. Definition and scope

In the graph-coordination setting of “Team Coordination on Graphs with State-Dependent Edge Cost,” the base environment graph is $G=(V,E)$, agents occupy vertices of $V$, and a joint state is an $m$-tuple

$s=(s_1,s_2,\dots,s_m)\in S_{\mathrm{JSG}}:=V^m.$

For $m=2$, the notation $s_{ij}$ denotes $(s_1=i,s_2=j)$, and the joint-state graph is $J=(S_{\mathrm{JSG}},L)$, where $L$ contains allowed tuple-to-tuple transitions and each such transition has a scalar cost $G=(V,E)$0 (Oughourli et al., 2023). This construction is expressly motivated by the addition of a “support” action, under which one agent can reduce the cost for its teammate to traverse some edges that have higher costs otherwise; because of that feature, the traversal problem is no longer a standard multi-agent path planning problem (Oughourli et al., 2023).

The later extension on Team Coordination on Graphs with Risky Edges (TCGRE) retains the same core idea but develops it over a simplified graph $G=(V,E)$1 whose vertices $G=(V,E)$2 are “special” nodes, including every agent start/goal, every endpoint of a risky edge, and every support node of a risky edge (Zhou et al., 8 Sep 2025). There, a joint state is an $G=(V,E)$3-tuple of robot locations on $G=(V,E)$4,

$G=(V,E)$5

with node set $G=(V,E)$6 (Zhou et al., 8 Sep 2025).

In CSS syndrome decoding, the terminology is structurally different. The construction consists of two binary Tanner graphs coupled by a local joint prior at each qubit. Each qubit $G=(V,E)$7 carries two binary random variables, $G=(V,E)$8 and $G=(V,E)$9, and the local factor

$V$0

connects the two components (Kasai, 6 May 2026). The paper calls the resulting factorization and its sum-product algorithm “joint BP,” and the supporting graph is described there as a Joint-State Graph (Kasai, 6 May 2026).

A plausible implication is that “JSG” is best understood as a family of lifted graphical representations whose common purpose is to make cross-component dependence explicit, either for shortest-path search or for probabilistic inference.

2. Joint-state construction for team coordination

The 2023 formulation begins with a directed environment graph $V$1 in which each edge $V$2 has two costs: a nominal cost $V$3 and a reduced cost $V$4 if that edge is supported. For each risk-edge $V$5, there is also a support-node set $V$6 (Oughourli et al., 2023). The JSG converts this team-coordination problem into a shortest-path problem on joint states.

For $V$7, an edge from $V$8 to $V$9 exists exactly when each agent either stays in place or moves along an original edge, namely when $m$0 and $m$1 (Oughourli et al., 2023). The edge cost is then defined casewise. If agent 1 stays and agent 2 moves, then support is possible when the stationary location of agent 1 lies in the support-node set for the moving edge. In that case,

$m$2

and otherwise $m$3 (Oughourli et al., 2023). The symmetric rule holds when agent 2 stays and agent 1 moves. If both move, each pays nominal cost independent of support, so

$m$4

and if both stay, the cost is zero (Oughourli et al., 2023).

For general $m$5, an edge from $m$6 to $m$7 exists if each agent either stays or moves along $m$8, and the cost is the sum over agents of either nominal cost or supported-cost plus support-penalty when exactly one agent is moving on an edge for which another agent is stationed in a support set (Oughourli et al., 2023).

The 2025 extension generalizes the cost model by computing support assignments through a maximum-weight bipartite matching. If $m$9 is the set of agents traversing risky super-edges and $s=(s_1,s_2,\dots,s_m)\in S_{\mathrm{JSG}}:=V^m.$0 is the set of agents located at support nodes, then a complete bipartite graph $s=(s_1,s_2,\dots,s_m)\in S_{\mathrm{JSG}}:=V^m.$1 is formed, with edge weight

$s=(s_1,s_2,\dots,s_m)\in S_{\mathrm{JSG}}:=V^m.$2

whenever agent $s=(s_1,s_2,\dots,s_m)\in S_{\mathrm{JSG}}:=V^m.$3 moves on a risky super-edge and agent $s=(s_1,s_2,\dots,s_m)\in S_{\mathrm{JSG}}:=V^m.$4 stands on its support node (Zhou et al., 8 Sep 2025). The joint-edge cost is

$s=(s_1,s_2,\dots,s_m)\in S_{\mathrm{JSG}}:=V^m.$5

so the system begins from the uncoordinated cost sum and subtracts the maximum total savings achievable by pairing risky-edge traversals with available support nodes (Zhou et al., 8 Sep 2025).

This evolution from explicit case distinctions to a matching-based cost function suggests a shift from pairwise support encoding toward a more systematic combinatorial treatment of simultaneous support opportunities.

3. Algorithms and planning workflow

The static JSG workflow in the 2023 account has two stages. First, the full joint-state graph is constructed by enumerating all tuples in $s=(s_1,s_2,\dots,s_m)\in S_{\mathrm{JSG}}:=V^m.$6, checking whether each candidate successor differs by valid local moves or stays, and assigning edge weights according to whether an agent moves alone with support, moves without support, both move, or stays (Oughourli et al., 2023). Second, a standard shortest-path algorithm such as Dijkstra or A* is run on the resulting graph from $s=(s_1,s_2,\dots,s_m)\in S_{\mathrm{JSG}}:=V^m.$7 to $s=(s_1,s_2,\dots,s_m)\in S_{\mathrm{JSG}}:=V^m.$8, yielding a joint-state path from which individual trajectories can be extracted (Oughourli et al., 2023).

The 2025 extension gives a full-expansion algorithm over the simplified graph $s=(s_1,s_2,\dots,s_m)\in S_{\mathrm{JSG}}:=V^m.$9. It enumerates all $m=2$0-tuples in $m=2$1; for each joint state and each choice of $m=2$2 super-edges in $m=2$3, it constructs the successor tuple, computes the uncoordinated sum $m=2$4, builds the bipartite graph between agents moving on risky edges and agents on support nodes, solves maximum-weight matching by Hungarian in $m=2$5, and assigns edge weight $m=2$6 (Zhou et al., 8 Sep 2025). The resulting graph again supports shortest-path search by Dijkstra.

The same paper then proposes Dynamic-HJSG, which interleaves graph search with on-the-fly node and edge generation rather than building $m=2$7 in advance. Its key data structures are a min-priority queue of discovered joint states keyed by $m=2$8, a hash map $m=2$9, $s_{ij}$0, and a visited set (Zhou et al., 8 Sep 2025). Successor generation is pruned by only allowing up to two agents to move at once, and each edge cost is computed by the same matching-based routine (Zhou et al., 8 Sep 2025).

The following table organizes the principal planning variants stated in the sources.

Variant	Core construction	Search mode
JSG	Full joint-state graph over $s_{ij}$1 or $s_{ij}$2	Dijkstra or A* (Oughourli et al., 2023), Dijkstra (Zhou et al., 8 Sep 2025)
CJSG	Smaller graph over “critical” joint-states	Two-level planning with high-level Dijkstra (Oughourli et al., 2023)
Dynamic-HJSG	On-the-fly construction with $s_{ij}$3 moving agents per step	Priority-queue search on discovered states (Zhou et al., 8 Sep 2025)

Within this family, the algorithmic role of JSG is stable: it serves as the substrate on which coordination is optimized by graph search. What changes across variants is whether the graph is fully materialized, reduced to critical states, or constructed lazily.

4. Complexity and scalability

The principal drawback of the naïve JSG approach is the curse of dimensionality in both the number of agents and the size of the graph (Oughourli et al., 2023). In the 2023 formulation, the number of nodes is $s_{ij}$4. Each agent has at most $s_{ij}$5 move-or-stay choices, so the total outgoing edges per joint state are at most $s_{ij}$6, giving

$s_{ij}$7

In the dense worst case $s_{ij}$8, one obtains $s_{ij}$9 (Oughourli et al., 2023). Space to store the JSG is $(s_1=i,s_2=j)$0, time to build it is approximately $(s_1=i,s_2=j)$1, and Dijkstra search takes

$(s_1=i,s_2=j)$2

For $(s_1=i,s_2=j)$3, this becomes $(s_1=i,s_2=j)$4, $(s_1=i,s_2=j)$5, so a direct JSG method is $(s_1=i,s_2=j)$6 (Oughourli et al., 2023).

The 2025 paper restates the static complexity in terms of the simplified graph size. Let $(s_1=i,s_2=j)$7, $(s_1=i,s_2=j)$8, and $(s_1=i,s_2=j)$9 be the maximum degree in $J=(S_{\mathrm{JSG}},L)$0. Then static JSG has $J=(S_{\mathrm{JSG}},L)$1 joint states and at most $J=(S_{\mathrm{JSG}},L)$2 edges, with build time $J=(S_{\mathrm{JSG}},L)$3 due to matchings, plus Dijkstra time $J=(S_{\mathrm{JSG}},L)$4; the method is therefore exponential in $J=(S_{\mathrm{JSG}},L)$5 and in $J=(S_{\mathrm{JSG}},L)$6 (Zhou et al., 8 Sep 2025).

Dynamic-HJSG seeks to reduce effective complexity by expanding only discovered states and pruning transitions to those in which at most two agents move. If $J=(S_{\mathrm{JSG}},L)$7 is the number of joint states actually expanded, then each state has $J=(S_{\mathrm{JSG}},L)$8 neighbors, total edges examined are $J=(S_{\mathrm{JSG}},L)$9, each edge cost via Hungarian is $L$0, and each expansion performs extract-min or update in $L$1. The overall time is

$L$2

with space $L$3 (Zhou et al., 8 Sep 2025).

These bounds establish a consistent theme: JSG provides exact coordination at the price of state-space explosion, and subsequent work concentrates on preserving optimality while avoiding full enumeration.

5. Hierarchical and dynamic reductions

The 2023 paper introduces a hierarchical decomposition called the Critical Joint-State Graph (CJSG) in order to avoid the $L$4 blow-up (Oughourli et al., 2023). The idea is to construct a smaller graph only over “critical” joint states at which a support interaction can begin or end. Between such states, each agent travels decoupled along its own shortest path (Oughourli et al., 2023).

The procedure has two levels. First, one identifies all risk edges $L$5 with $L$6. For each such edge and each support node $L$7, two critical joint states are introduced, $L$8 and $L$9, together with the start state and goal state (Oughourli et al., 2023). Second, these critical states are fully connected. The cost of an edge $G=(V,E)$00 from $G=(V,E)$01 to $G=(V,E)$02 is

$G=(V,E)$03

where

$G=(V,E)$04

and $G=(V,E)$05 is the single-agent shortest-path cost on $G=(V,E)$06 from $G=(V,E)$07 to $G=(V,E)$08 with no support (Oughourli et al., 2023). If the transition corresponds exactly to one risk edge having support, then

$G=(V,E)$09

and $G=(V,E)$10 is the minimum of the supported and unsupported costs (Oughourli et al., 2023). By Lemma III.1, this preserves optimality while producing a graph whose size $G=(V,E)$11 can be much smaller than $G=(V,E)$12 when the number of risk edges and support nodes is small (Oughourli et al., 2023).

The 2025 work moves from hierarchical reduction to dynamic construction. Dynamic-HJSG does not precompute the entire graph; it constructs successors on demand and uses the fact that coordination is intrinsically pairwise to justify restricting each joint transition to at most two moving agents (Zhou et al., 8 Sep 2025). Lemma 1 states that this restriction does not lose any optimal coordination paths, since any multi-agent simultaneous move can be broken into a sequence of at most-2 moves without increasing total cost (Zhou et al., 8 Sep 2025).

A plausible implication is that CJSG and Dynamic-HJSG target complementary axes of the same scalability problem. CJSG compresses the graph by exploiting sparsity in support opportunities, while Dynamic-HJSG compresses search effort by exploiting pairwise structure and lazy expansion.

6. Worked examples and domain-specific reinterpretation

The 2023 paper provides a concrete 3-node, 2-agent example. Let

$G=(V,E)$13

with both agents starting at 1 and both targeting 2 (Oughourli et al., 2023). The edge $G=(V,E)$14 is risky with nominal cost $G=(V,E)$15, reduced cost $G=(V,E)$16, support penalty $G=(V,E)$17, and support-node set $G=(V,E)$18 (Oughourli et al., 2023). The direct JSG contains 9 states. Dijkstra on those states finds the three-step path

$G=(V,E)$19

with total cost $G=(V,E)$20, whereas the direct simultaneous jump $G=(V,E)$21 costs $G=(V,E)$22 (Oughourli et al., 2023). The corresponding CJSG contains only four critical states, $G=(V,E)$23, $G=(V,E)$24, $G=(V,E)$25, and $G=(V,E)$26, and yields the same optimal path and cost (Oughourli et al., 2023).

The 2025 paper gives a 4-node toy environment with nodes $G=(V,E)$27, risky edge $G=(V,E)$28 of cost 5 supported by node $G=(V,E)$29, edges $G=(V,E)$30 and $G=(V,E)$31 of cost 1, and $G=(V,E)$32 of cost 7; the reduced cost on $G=(V,E)$33 with support is 2 (Zhou et al., 8 Sep 2025). With two agents, $G=(V,E)$34 gives 16 possible joint states. From $G=(V,E)$35 to $G=(V,E)$36, agent 1 traverses the risky edge and agent 2 remains at the support node, so the bipartite matching yields $G=(V,E)$37 and cost $G=(V,E)$38, matching the reduced-cost traversal (Zhou et al., 8 Sep 2025).

In the CSS-decoding setting, the worked structure is not a shortest-path example but a factorization of the posterior: $G=(V,E)$39 with all sums modulo 2 (Kasai, 6 May 2026). Variable-to-factor, check-to-variable, and local-prior-to-variable message updates then follow the standard sum-product rules on this graph (Kasai, 6 May 2026). The joint belief at qubit $G=(V,E)$40 is

$G=(V,E)$41

and hard decisions are taken by maximizing $G=(V,E)$42 over $G=(V,E)$43 (Kasai, 6 May 2026).

The juxtaposition of these examples clarifies that “joint state” can mean either a tuple of agent positions in a planning graph or a locally coupled pair of binary error variables in a factor graph. The commonality lies in explicit representation of interdependence; the operational semantics differ substantially.

7. Relation to adjacent frameworks and common misconceptions

In team coordination on graphs, JSG is not identical to standard multi-agent path planning. The 2023 formulation states that incorporating support action causes graph traversal to be no longer a standard multi-agent path planning problem (Oughourli et al., 2023). The later TCGRE work further shows that the underlying coordination problem reduces from Minimum 3-Dimensional Matching and is NP-hard (Zhou et al., 8 Sep 2025). This rules out the misconception that JSG is merely a cosmetic reformulation of an ordinary MAPF instance.

JSG is also not synonymous with any single solver. In the TCGRE line, it is one component of a larger methodological family that also includes Coordination-Exhaustive Search (CES) and Receding-Horizon Optimistic Cooperative A* (RHOCA*) (Zhou et al., 8 Sep 2025). Dynamic-HJSG is a variant of JSG construction rather than a different problem definition (Zhou et al., 8 Sep 2025).

In CSS decoding, joint BP should not be confused with a quaternary-state formulation that uses a different posterior. The 2026 note shows that joint BP and four-state BP have the same posterior weights, messages, and beliefs after relabeling the four local Pauli states and marginalizing the irrelevant binary component (Kasai, 6 May 2026). The distinction is therefore representational rather than inferential. The JSG in that setting keeps $G=(V,E)$44 binary variables, one local $G=(V,E)$45-table factor per qubit, and usual binary check-node operations, while preserving all $G=(V,E)$46 correlations at only a constant $G=(V,E)$47 marginalization cost per qubit (Kasai, 6 May 2026).

A final misconception is that optimality-preserving reductions necessarily require full global coupling. In the coordination literature, both CJSG and Dynamic-HJSG are explicitly presented as optimality-preserving under their stated lemmas and theorems (Oughourli et al., 2023, Zhou et al., 8 Sep 2025). This suggests that the essential coupling structure is often sparser or more pairwise than the full Cartesian product representation initially indicates.