Game-Theoretic Nested Search (GTNS)

• Game-Theoretic Nested Search is a framework that computes Nash equilibria for multi-robot planning with nonlinear dynamics and stringent collision constraints.
• It uses a nested A* search over discretized kinodynamic motion graphs to efficiently prune non-NE trajectories while ensuring optimality.
• The method is validated in autonomous driving and racing scenarios, achieving fast and reliable solutions for up to 3 agents on standard hardware.

Game-Theoretic Nested Search (GTNS) is a scalable, provably correct algorithmic framework for computing Nash equilibria (NE) in multi-robot motion planning tasks governed by general nonlinear dynamics and hard constraints. GTNS operates by nesting best-response search for violating deviations within a global graph-based search, ensuring that only NE-feasible trajectories are explored. It allows for explicit selection among multiple equilibria using user-specified global objectives and is demonstrated to solve complex, realistic driving and racing scenarios in seconds on standard hardware (Engle et al., 11 Nov 2025).

1. Formal Problem Setting

GTNS addresses multi-agent, continuous-time optimal control games with $m \geq 2$ robots (agents) indexed by $i \in [m]=\{1,\ldots,m\}$. Each agent has:

• State $x^i(t) \in X^i \subseteq \mathbb{R}^{d_i}$ and control $u^i(t) \in U^i \subseteq \mathbb{R}^{D_i}$ governed by

$$\dot{x}^i(t) = f^i(x^i(t), u^i(t)),\quad x^i(0) = x_0^i.$$

• Admissible control functions $u^i: [0, T] \to U^i$ over horizon $T$, and the set of corresponding feasible trajectories $\Pi^i_T$.
• Joint system state $$x(t) = (x^1(t), \ldots, x^m(t)) \in X = \prod_{i=1}^m X^i$$ and controls $u(t) \in U = \prod U^i$.
• Individual cost (payoff) functional:

$$J^i(\pi^i, \pi^{-i}) = \int_0^T c^i(\pi^i(t), \pi^{-i}(t))\, \mathrm{d}t$$

with $\pi^{-i}$ denoting other agents' trajectories, and $c^i$ a nonnegative stage cost.

The planning problem requires:

• Collision-avoidance: $x(t) \in X_f \subset X$ for all $t$, rejecting both static and inter-robot collisions.
• Goal attainment: $$\pi(T) \in X_{\mathrm{goal}} = \prod X^i_{\mathrm{goal}}$$.

A joint trajectory $\pi = (\pi^1,\ldots,\pi^m)$ is a pure NE if for every $i$,

$$J^i(\pi^i, \pi^{-i}) \leq J^i(\tilde{\pi}^i, \pi^{-i})\quad \forall\, \tilde{\pi}^i \in \Pi^i_T$$

with no agent able to unilaterally reduce its individual cost.

A global objective

$J(\pi) = \int_0^T c(\pi(t))\, \mathrm{d}t$

is used to select among multiple NEs, for example by enforcing a social welfare or fairness criterion. The “Optimal-NE” is a joint trajectory that is (i) a NE, (ii) globally cost-minimizing among NEs, (iii) collision-free, and (iv) goal-attaining.

2. GTNS Algorithmic Framework

Direct search in the joint continuous trajectory space is intractable in high dimensions. GTNS circumvents this by:

1. Discretizing agent dynamics as kinodynamic motion graphs,
2. Constructing an implicit joint tensor-product graph,
3. Performing nested A* search to ensure only NE-compliant trajectories are considered.

2.1 Kinodynamic Graph Construction

For each agent $i$, a directed graph $G^i = (V^i, E^i)$ is built:

• $V^i$ is a finite set of sampled states (including start and goal states).
• Each edge $e^i = (x^i, y^i) \in E^i$ represents a dynamically feasible local trajectory segment.

2.2 Tensor-Product Joint Graph

The joint graph $G = (V, E)$, defined implicitly, has:

• $V = \prod_{i=1}^m V^i$ (joint agent states),
• $E = \prod_{i=1}^m E^i$ (joint action combinations).

Adjacency is generated on-demand via the Cartesian product of neighbors, eliminating the need to explicitly materialize the joint graph.

2.3 Nested A* Search

GTNS employs two nested search levels:

• Outer A*: Searches over the joint graph, maintaining for each node a joint trajectory and key $f(\pi_x) = J(\pi_x) + H(x)$ (global cost plus heuristic).
• Inner A*: For each joint trajectory candidate, checks the NE property by running a single-agent best-response A* over $G^i$ to find unilateral deviations of equal length $n$; if any agent can improve its cost, the joint trajectory is pruned.

The pruning criterion is based on the monotonicity of the NE property: if a joint prefix is not a NE, no extension can ever recover NE feasibility.

The global cost $J(\pi)$ embedded in the outer A* key allows explicit selection of the optimal NE with respect to the user’s objective.

2.4 Algorithmic Pseudocode

The high-level logic consists of:

• GTNS: Outer A* search over joint states.
• isNashEquilibrium: For a joint path, invokes inner search for each agent.
• BestResponseAStar: Finds the lowest-cost unilateral deviation of fixed length, constrained to avoid collisions against fixed opponents’ trajectories.

Full pseudocode, adhering to the above search logic and pruning rules, is provided in the primary source (Engle et al., 11 Nov 2025).

3. Theoretical Properties and Complexity

• Correctness: The monotonicity lemma establishes that if a joint path is not a NE, no extension can become NE. Thus, pruning unsafe (non-NE) prefixes is lossless.
• Optimality: With an admissible heuristic $H$, standard A* theory guarantees that the first goal node found corresponds to an optimal NE.
• Complexity: Outer A* expansions branch into $\prod_i \deg(x^i)$ joint neighbors. Each neighbor requires an inner A* (one per agent) of complexity $O(|E^i| + |V^i| \log |V^i|)$. While worst-case scaling is exponential in the number of agents $m$, practical branching factors and agent counts (typically $m \le 3$) enable tractable solution times.

Empirical results show that horizons $T \approx 15$–20\,s and $m \le 3$ can be solved in wall-clock times from $0.1$ to $5$ seconds on commodity hardware.

4. Implementation Details

4.1 Robot Dynamics

Demonstrations employ a second-order bicycle model:

$$\mathbf{x} = (x, y, \theta, v, \delta), \quad \dot{x}=v\cos\theta,\ \dot{y}=v\sin\theta,\ \dot{\theta}=\frac{v}{L}\tan\delta, \ \dot{v}=a,\ \dot{\delta}=\omega$$

with input constraints $|a| \leq 5\,\text{m/s}^2$, $|\omega| \leq 2\,\text{rad/s}$, $v \in [0,10]\,\text{m/s}$, $\delta \in [-\pi/2, \pi/2]$.

4.2 Graph Discretization

Two modes:

• Grid graph: Uniform discretization over $\{x, y, \theta, v, \delta\}$; edges constructed via boundary-value problem solvers.
• Track graph: For racetrack scenarios, longitudinal sampling along centerline with lateral offsets.
• Both approaches rely on offline construction of feasible trajectories and collision maps ($\approx 10^4$–$10^5$ local BVPs).

4.3 Heuristics and Data Structures

• Heuristics: Precomputed single-agent shortest-path costs to goal (e.g., via Dijkstra or Floyd–Warshall), summed across agents for admissibility.
• Data structures: Min-heap for OPEN list; hash tables for CLOSED sets; caching and lazy validation for efficiency.

4.4 Hardware and Practical Efficiency

The reference implementation is C++ on a standard laptop (Intel i9-14900HX, 32 GB RAM), achieving solve times ranging from $0.1$ to $5$ seconds for $m=2,3$ agents and $T \leq 20$ seconds, with no GPU required.

5. Empirical Validation and Comparison

GTNS is evaluated on diverse autonomous driving and racing benchmarks:

• Four-way intersections,
• Three-lane highway merges,
• Opposing-lane overtakes,
• Racetrack S-curves,
• Following-distance scenarios.

Quantitative results for a representative “generic” map of $|V| \approx 7{,}000$, $|E| \approx 5 \times 10^4$ are shown below:

Map	$|V|$	$|E|$	$m$	D=7	9	11	13	15	17
Generic, no obs	7,560	51,733	2	3.31	0.05	2.11	1.57	0.06	4.73
Generic, no obs			3	396.1	3.7	59.1	16.2	9.0	178.5
Generic + obs	6,300	25,818	2	0.05	0.04	1.28	0.67	0.80	0.14
Generic + obs			3	15.1	34.0	3.79	12.2	4.58	12.0

Compared to optimization-based NE solvers (e.g., iLQGames, Stackelberg relaxations), GTNS avoids problems of local minima and convexification, and is not limited to two-player settings. Payoff-matrix enumeration approaches (e.g., Liniger & Lygeros) are computationally intractable for realistic problem sizes ($K^m$ growth; combinatorial explosion with horizon and agent count). GTNS, by contrast, scales to realistic multi-agent scenarios with complex dynamics and hard constraints while ensuring global optimality over NEs (Engle et al., 11 Nov 2025).

6. Scope, Limitations, and Research Connections

GTNS guarantees provable correctness (NE satisfaction and global cost optimality), scalability to $m \le 3$ agents over planning horizons up to $20$ seconds, and flexibility in cost structuring (supporting arbitrary user objectives including social welfare, priorities, and fairness). The main current limitation is exponential scaling in the number of agents due to the implicit joint graph expansion. Further, computational requirements scale with the discretization density and horizon.

The algorithm bridges a significant gap between optimization-based NE solvers (which struggle with nonlinearity, hard constraints, and local minima) and payoff-matrix or enumeration-based methods (which are infeasible for high-dimensional, long-horizon tasks). A plausible implication is that this nested-search methodology could be extensible to other dynamical game domains where the number of agents is moderate and user-specified global objectives are important.

7. Summary

Game-Theoretic Nested Search is a highly structured, provably correct framework for multi-robot, game-theoretic planning with nonlinear dynamics and hard constraints. By combining joint-graph and best-response search, and explicit pruning via monotonic NE checks, GTNS elects optimal NEs in scenarios where prior approaches are computationally impractical or fail to guarantee global solution optimality. It provides a practical method for behavior-aware decision making in competitive, cooperative, or mixed-mode multi-robot systems, as demonstrated in autonomous driving and racing benchmarks (Engle et al., 11 Nov 2025).