A New Math for Complex Strategic Systems: How Game Petri Nets Can Model Everything from Cyberattacks to Maintenance Workflows
A single phishing email can trigger a chain of decisions that leads to a $10 million data breach. A missed inspection can cascade into a power plant failure. In both cases, the outcome of one small interaction determines what happens next: who acts, with what resources, and under what incentives. Yet until now, we’ve lacked a unified language to model these systems — not just their logic, but their strategy.
That changes with a new framework called outcome-driven compositional game Petri nets (OCGPNs), introduced by Quanyan Zhu in a 2026 working paper. The most striking result? A 39-segment enterprise cyber network — too large to analyze as a single game — can be broken down and solved with a computational cost that grows additively with complexity, not exponentially. Where a monolithic model would require roughly $10^{25}$ nodes, the decomposed OCGPN model needs only about $10^4$ (Zhu, 2026). That’s not just faster. It’s what makes large-scale strategic analysis possible.
This isn’t just a theoretical advance. It’s a new way to design, verify, and intervene in systems where strategy, structure, and sequence collide.
The Science
OCGPNs merge two powerful formalisms: Petri nets, long used to model concurrent systems like workflows and chemical reactions, and game theory, the mathematics of strategic decision-making. The innovation lies in how they’re connected.
In a standard Petri net, tokens flow through places and transitions, representing tasks, resources, or states. A transition fires when its input places have enough tokens, consuming them and producing new ones. Colored Petri nets add data to tokens — for example, a "work order" token might carry fields like id, status, and certified.
OCGPNs go further. They attach a local game to each game place. When a game resolves — say, a defender decides whether to patch a vulnerability — its outcome is converted into typed tokens via a game-to-token interface. These tokens then enable, block, or synchronize downstream transitions, including other games.
For example, if the defender chooses "patch", the system might generate a patched token that enables a compliance audit. If they choose "ignore", it might generate a vulnerable token that enables an attacker’s next move. The game decides; the net executes.
The model separates three layers:
- Structural net: the Petri net itself, with places, transitions, and colored tokens.
- Local games: strategic interactions at game places, with players, actions, payoffs, and outcome probabilities.
- Solution layer: equilibrium strategies and continuation values that link games across time.
Each layer has a corresponding mathematical object: the incidence matrix $C$ for structure, payoff and outcome matrices $(R^p, \Phi^p_\omega)$ for incentives, and the routing matrix $P^\sigma$ for values.
This separation is crucial. It means that guards — logical conditions on transitions — act only on the structural layer, while incentive instruments like rewards or deception act only on the game layer. You can’t use deception to prevent an attack; you can only make it less attractive. But you can use a guard to block it entirely. This isn’t just a modeling choice — it’s a design principle.
The theory is developed at two levels:
- General OCGPNs: support arbitrary concurrency, with multiple games active at once. Here, analysis relies on structural invariants and Farkas certificates derived from the incidence matrix.
- Sequential OCGPNs: only one game is active at a time. Here, the net induces a stochastic game over game places, enabling efficient value computation via backward induction over strongly connected components (SCCs).
The sequential case is where the computational breakthrough happens. By decomposing the place graph into SCCs and solving them in reverse topological order, the cost of computing equilibrium values becomes additive in the size of local games — not multiplicative. This is what shrinks the problem from $10^{25}$ to $10^4$.
What They Found
The paper presents two running examples that illustrate the full theory.
Example 1: Maintenance Workflow
The first is a cooperative workflow involving an operator, a provider, and a verifier. A task must be completed, inspected, and certified. If inspection fails, it goes into a rework loop.
The key insight? Graded routing — where the outcome of inspection (e.g., "minor defect", "major defect") determines the next step — can reverse a myopic equilibrium. In a binary system ("pass"/"fail"), the provider has no incentive to exert high effort, since both outcomes lead to the same rework process. But with graded routing, a "minor defect" might trigger a lighter rework, making high effort worthwhile.
Moreover, the rework loop sustains cooperation only if rework is costly. If rework is cheap, the provider prefers to fail and retry, undermining the incentive to get it right the first time. This is a subtle but critical design insight: forgiveness can destroy cooperation.
Example 2: Intrusion Campaign
The second example models a multi-stage cyberattack across a 39-segment enterprise network, based on real-world multi-resolution cyber-defense games (Zhu, 2026). Each segment hosts a local game between attacker and defender, with actions like "phish", "exploit", "defend", "deceive".
Here, the model shows that deception — such as deploying honeypots or fake credentials — lowers the attacker’s expected value but does not remove reachability. The attacker can still reach the target; they just expect to gain less. This is a fundamental limit of deception: it changes payoffs, not possibilities.
In contrast, a lockdown guard — a structural rule that blocks transitions unless certain conditions are met — can certify unreachability. For instance, a rule that disables lateral movement unless a valid token is present can make certain attack paths impossible.
The most powerful demonstration is composition: a newly discovered phishing scenario is added to the existing campaign. Because the OCGPN is compositional, this new subnet can be analyzed in isolation, summarized by its entry values, and fused with the main campaign without re-solving the entire system. This is impossible in monolithic models.
Key Results
- Global equilibria in sequential OCGPNs are exactly collections of local equilibria augmented by continuation values — the expected future payoff from downstream games (Theorem 4).
- Successor-level pivotality determines when downstream games affect upstream behavior: if a change in a downstream game alters the relative value of upstream actions, it can shift equilibrium (Proposition 9).
- Composition via place fusion allows subnets to be glued together, with invariants and certificates preserved (Lemma 1).
- Value computation is place-by-place over SCCs, with cost additive in local game sizes (Theorem 5).
Computational Complexity: Monolithic vs. Composed Model
| Label | Value |
|---|---|
| Monolithic Stochastic Game | 10,000,000,000,000,000,000,000,000 |
| Composed OCGPN | 10,000 |
Capabilities of OCGPN vs. Existing Formalisms
| Label | Value |
|---|---|
| Strategic Players | 1 |
| Concurrency | 1 |
| Typed Resources | 1 |
| Composition Operators | 1 |
| Structural Certificates | 1 |
| Decomposed Values | 1 |
Why This Changes Things
Today, most strategic modeling faces a trade-off: you can have rich structure (Petri nets, attack graphs) or rich strategy (stochastic games, extensive-form games), but not both. OCGPNs break that trade-off.
Consider cybersecurity. Attack graphs model the structure of multi-step attacks but assume attackers follow shortest paths, ignoring incentives. Game-theoretic models capture incentives but struggle with scale and concurrency. OCGPNs do both: they model the attacker’s strategic choices and the network’s structural constraints, with typed tokens representing credentials, access levels, and telemetry.
The same applies to AI pipelines. A multi-agent system might involve delegation, verification, and reward shaping. Each step is a game, and its outcome — success, failure, fraud — determines what happens next. OCGPNs can model this entire pipeline, showing how downstream verification incentives affect upstream behavior.
But perhaps the most profound implication is design guidance. The separation of layers tells us what tools to use when:
- Want to prevent an outcome? Use a guard — a structural constraint.
- Want to discourage an outcome? Use incentives — payoffs, deception, rewards.
- Want to enable cooperation? Design graded routing and make rework costly.
This isn’t just analysis. It’s a grammar for building better systems.
Compare this to current practice. In cyber defense, deception is often sold as a silver bullet. But OCGPNs show its limits: it reduces attacker value, but doesn’t block paths. To truly secure a system, you need both — deception and structural guards.
Similarly, in organizational design, workflows are often built with binary outcomes ("approve"/"reject"). But OCGPNs show that graded feedback can restore incentives that binary routing destroys.
The framework also clarifies a deep principle: downstream games change upstream behavior only when they are pivotal. If a defender knows that patching a vulnerability will only delay an inevitable breach, they won’t bother. But if patching changes the probability of a successful attack downstream, it becomes worthwhile. This is the essence of successor-level pivotality — and it’s a principle that applies to climate policy, supply chains, and pandemic response.
What’s Next
OCGPNs are a foundation, not a finished tool. Several challenges remain.
First, scalability in the concurrent case. While sequential nets are efficiently solvable, general concurrent OCGPNs rely on structural certificates that don’t compute values. Extending the SCC decomposition to concurrent settings — perhaps via partial-order reduction or net unfolding — is a major open problem.
Second, learning and adaptation. The current model assumes rational players with known payoffs. But in real systems, agents learn. Integrating reinforcement learning or empirical game analysis into the OCGPN framework could bridge theory and practice.
Third, tooling and verification. We need software that can parse OCGPNs, check invariants, compute equilibria, and visualize attacks. The paper’s examples are hand-analyzed; automation is essential for real-world use.
Fourth, equilibrium selection. In games with multiple equilibria, which one emerges? The model allows for equilibrium selection via the solution layer, but practical mechanisms — like focal points or learning dynamics — need to be incorporated.
Finally, applications beyond security and workflows. Could OCGPNs model political negotiations, where each concession enables new talks? Or ecological management, where a policy decision affects which species interactions become possible? The framework is general, but its power will be proven in diverse domains.
The most exciting prospect is compositional security-by-design. Imagine a library of verified subnets — authentication modules, data pipelines, control loops — each with certified properties and known entry values. New systems could be built by fusing these components, with safety and incentive properties guaranteed by the composition calculus. This is the dream of modular, trustworthy system design.
We are no longer limited to analyzing systems as monoliths or ignoring strategy to focus on structure. With OCGPNs, we can finally model the world as it is: a web of strategic interactions, where every decision ripples forward, shaping who acts, with what, and why.
As Zhu writes: "A newly discovered attack scenario can be composed with an existing campaign without re-solving it." That sentence — and the mathematics behind it — may one day be seen as the moment we learned how to think clearly about complex strategic systems.