How to Teach AI the Rules of Human Conflict — With Mathematical Guarantees

0.03 seconds. That’s how long it takes to predict the equilibrium behavior of 10 interacting agents after learning from just 50 noisy observations of past conflicts — whether they’re drivers jostling for space on a highway or energy traders bidding in a deregulated market. According to a new paper by Mallick, Baghbadorani, Esfahani, and Grammatico (2026), this speed and robustness aren’t accidental. They emerge from a foundational shift in how we teach machines to understand strategic human behavior.

For decades, artificial intelligence has struggled with one of social science’s oldest questions: given that people act in their own interest, can we reverse-engineer their goals from what they do? This is the domain of inverse game theory — a cousin of inverse reinforcement learning, but designed for multi-agent settings where every player’s choice depends on others’. Prior methods tried to match observed outcomes by minimizing residuals in optimality conditions. But those approaches often led to ill-behaved models: non-convex training problems, unstable equilibria, and predictions that broke down under slight perturbations.

This new work changes the game. Instead of chasing gradients, the researchers build a convex, tractable, and theoretically grounded framework that doesn’t just fit data — it guarantees that the learned model will produce reliable future predictions. At its core is a simple insight: if you want to learn rules that lead to stable outcomes, you must bake stability into the learning process itself.

The Science

The authors tackle the inverse problem of non-cooperative games: given a dataset of exogenous signals $s$ (like traffic density or electricity prices) and observed Nash equilibria $u$, infer the underlying cost functions $J^i(u^i, u^{-i} | s)$ that each agent $i$ is minimizing. These functions encode private preferences — how much a driver values speed versus safety, or how risk-averse a trader is.

Rather than assuming full knowledge of agent dynamics, the observer only sees signal-equilibrium pairs $\mathcal{D} = {(\tilde{s}_t, \tilde{u}t)}{t=1}^T$. Their goal isn’t perfect identification of true parameters, but predictive accuracy: when a new signal appears, can the model forecast the resulting equilibrium?

To ensure this, the authors introduce two structural safeguards:

First, they use the Nikaido–Isoda (NI) loss, derived from a classic function in game theory that measures how much agents could improve their payoffs by deviating unilaterally. Minimizing this loss directly aligns with the definition of a Nash equilibrium — no player benefits from changing strategy alone.

Second, they enforce strong monotonicity of the pseudogradient operator $F_\theta(s,u) := \mathrm{col}(\nabla_{u^i} J^i_\theta)$, which captures how each agent’s marginal cost responds to changes in joint actions. Strong monotonicity — the condition that $\langle F(u) - F(v), u - v \rangle \geq \zeta |u - v|^2$ for some $\zeta > 0$ — ensures uniqueness and stability of equilibria, and enables convergence of standard algorithms like gradient play.

For linear-quadratic games, they show that minimizing the NI loss subject to Linear Matrix Inequality (LMI) constraints on the Jacobian $\nabla_u F_\theta$ leads to a semidefinite program (SDP) — a class of convex optimization problems that modern solvers handle efficiently.

In more complex, nonparametric settings, they go further: using a Helmholtz–Hodge decomposition in a reproducing kernel Hilbert space (RKHS), they decompose the game operator into a potential (gradient-like) component and a divergence-free remainder. By constraining the latter to zero, they recover a strongly monotone operator without sacrificing expressivity.

When data is noisy — as it always is in real systems — they propose a receding-horizon learning scheme with adaptive Tikhonov regularization. Crucially, they prove this regularization admits a maximum a posteriori (MAP) interpretation: it’s equivalent to updating beliefs about the true parameter in a Bayesian framework, where uncertainty evolves over time.

What They Found

The numerical experiments reveal striking performance. In a stylized autonomous vehicle collision-avoidance scenario involving multiple cars negotiating right-of-way at an unsignalized intersection, the model learns driving preferences from trajectory data — even when those trajectories are corrupted by significant measurement noise.

Mean Prediction Error vs. Training Data Size

Label	Value
T=10	0.42
T=25	0.21
T=50	0.09
T=100	0.04

Error decreases by 90% when training data grows from 10 to 100 samples.

shows how mean prediction error $\mathbf{e}T = \frac{1}{T'} \sum{t=1}^{T'} |u_t^* - \hat{u}_t|$ collapses as training data size increases. With only 10 samples, the model errs by 42% of the action space diameter. But with 100, error drops to just 4%. This rapid convergence suggests the method is data-efficient — critical for applications where collecting clean equilibrium data is expensive.

Even more impressive is its robustness.

Prediction Accuracy Under Increasing Noise Levels

Label	Value
σ=0.1	0.06
σ=0.2	0.08
σ=0.3	0.11
σ=0.4	0.15

At highest noise level (σ=0.4), NI-based model has 53% lower error than FO counterpart.

compares the NI loss against the traditional first-order (FO) loss under increasing levels of additive Gaussian noise ($\sigma = 0.1$ to $0.4$). While both degrade, the NI-based model consistently outperforms FO, maintaining 53% lower error at the highest noise level. This resilience stems from the NI loss’s tighter connection to equilibrium structure — it doesn’t just penalize KKT violations; it quantifies actual incentive misalignment.

The theoretical guarantees hold in practice. Across 100 test scenarios, the observed prediction error stayed below the theoretical bound $\sqrt{\eta_T / \zeta}$ in over 95% of cases — matching the $1-\alpha$ confidence level promised by Theorem 3.5. And because the learned game remains strongly monotone, equilibrium-finding algorithms converge reliably, unlike models trained with unstructured losses.

One key result comes from the dynamic extension. Using randomized trace estimation to approximate the covariance of parameter uncertainty, the receding-horizon scheme updates its regularization weight online. As shown in

, this allows the model to "forget" outdated information and adapt to slowly drifting agent behaviors — say, drivers becoming more aggressive over time. The solution path tracks the true equilibrium far more closely than batch-trained alternatives.

Why This Changes Things

Until now, deploying learned game models in safety-critical systems has been risky. You might train a model on historical traffic patterns, only to find it predicts phantom gridlock or encourages dangerous overtaking — not because the data was bad, but because the internal logic of the game became pathological.

This work offers a way out. By making strong monotonicity enforceable rather than hoped-for, it shifts inverse game theory from a descriptive tool to a prescriptive engineering discipline. Now, designers can say: "I learned this model from data, and I know — with measurable confidence — that its predictions will be unique, stable, and physically plausible."

Consider smart cities. A central planner might want to anticipate how ride-sharing fleets, delivery drones, and personal vehicles will react to a new congestion pricing policy. Without structural guarantees, simulation results could swing wildly based on minor data fluctuations. With this framework, the city can run counterfactuals knowing the model won’t invent spurious equilibria.

Or consider digital marketplaces. Platforms like Airbnb or Uber implicitly manage games between hosts, guests, drivers, and riders. If the platform could accurately learn the utility functions behind booking and cancellation behavior, it could design better incentives — nudging toward higher service quality without distorting competition. But doing so safely requires trust in the model’s internal consistency. This method provides that.

Even beyond engineered systems, there’s potential for scientific insight. Economists studying peer-to-peer energy trading in microgrids could use this to infer household preferences from observed exchange patterns. Unlike black-box neural nets, the structured operators here are interpretable: the learned $R^i$ matrices reveal how sensitive each agent is to collective load, while $r^i(s)$ traces their response to price signals.

And perhaps most importantly, the probabilistic guarantee $\mathbb{P}[\mathbf{e}_T \leq \sqrt{\eta_T / \zeta}] \geq 1 - \alpha$ closes a long-standing gap between machine learning and control theory. It links empirical risk minimization directly to out-of-sample behavioral performance — not just loss values, but actual decision accuracy.

What's Next

No framework is a panacea. The current formulation assumes agents play exact Nash equilibria — a strong behavioral assumption. In reality, humans and even AI agents often satisfy only approximate equilibria, or follow heuristics. Future work could extend the NI loss to accommodate bounded rationality, perhaps by introducing slack variables or distributional assumptions on deviation costs.

Another limitation is scalability. While SDPs are tractable for small-to-medium games (up to ~50 agents in tests), they face computational bottlenecks in massive multi-agent systems. One path forward is operator sketching — using low-rank approximations within the RKHS framework to preserve monotonicity while reducing dimensionality.

The receding-horizon scheme works well for slowly varying dynamics, but assumes stationarity within each horizon. For rapidly evolving environments — say, financial markets during a crash — faster adaptation mechanisms may be needed. Online learning variants with dynamic regret bounds could help.

Finally, while the method enforces strong monotonicity, it does not yet incorporate causal structure. Two different sets of cost functions might produce identical equilibria but very different responses to interventions. Integrating tools from causal inference could allow the model to distinguish between observationally equivalent games — enabling truly counterfactual reasoning.

Still, the foundation is now solid. For the first time, we have a unified framework that treats game learning not as curve-fitting, but as design under uncertainty. It respects the mathematics of strategic interaction while embracing the messiness of real-world data. And in doing so, it brings us closer to building AI that doesn’t just predict human conflict — but understands the rules by which it unfolds.