Paper deep dive

Beyond Runtime Enforcement: Shield Synthesis as Defensibility Analysis for Adversarial Networks

Achraf Hsain, Sultan Almuhammadi

Year: 2026Venue: arXiv preprintArea: cs.AIType: PreprintEmbeddings: 84

Intelligence

Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 95%

Last extracted: 7/9/2026, 5:26:47 AM

Summary

The paper reframes shielded reinforcement learning (ShRL) and shield synthesis from runtime enforcement mechanisms to design-time analytical tools for defensibility analysis. By constructing a constrained two-player safety game with asymmetric temporal logic specifications for defender and attacker constraints, the authors demonstrate how to compute a formal defensibility verdict, winning regions, and topology-level metrics. Combining these formal outputs with shield-constrained adversarial multi-agent reinforcement learning yields a 'defensibility fingerprint' that captures both formal safety properties and operational behavior. The framework enables architectural what-if analysis, revealing that formal defensibility and operational effectiveness are distinct, thereby positioning shield synthesis as a powerful diagnostic framework for network security architecture rather than a deployment mechanism for safe agents.

Entities (12)

Shielded Reinforcement Learning · method · 98%Defensibility Analysis · concept · 97%Defensibility Verdict · output · 97%Shield Synthesis · method · 96%Two-player Safety Game · method · 96%Winning Region · concept · 96%Defensibility Fingerprint · output · 95%Temporal Logic · method · 95%Deterministic Finite Automaton · concept · 94%Multi-Agent Reinforcement Learning · method · 94%Network Defense Game · model · 93%Topology Defensibility Metrics · metric · 92%

Relation Signals (11)

Shield Synthesis → reframedas → Defensibility Analysis

confidence 97% · The same automata-theoretic machinery... is better read as a design-time analytical instrument

Winning Region → yields → Defensibility Verdict

confidence 97% · Solving the resulting game produces a defensibility verdict—a formal certificate that a topology-specification pair is or is not defensible

Two-player Safety Game → computes → Winning Region

confidence 96% · computes the winning region by attractor fixed-point iteration

Temporal Logic → compiledinto → Deterministic Finite Automaton

confidence 95% · Linear temporal logic (LTL) safety formulas... compile mechanically into safety automata

Defensibility Verdict → forms → Defensibility Fingerprint

confidence 95% · Together these form a defensibility fingerprint capturing both a network's formal safety properties and its operational behavior

Defensibility Fingerprint → captures → Formal Safety Properties

confidence 94% · capturing both a network's formal safety properties and its operational behavior under adaptive play

Defensibility Fingerprint → captures → Operational Behavior

confidence 94% · capturing both a network's formal safety properties and its operational behavior under adaptive play

→ →

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:Shielded reinforcement learning is typically presented as a runtime safety mechanism that compiles temporal-logic specifications into automata restricting an agent's actions. We argue this is the wrong product. The same automata-theoretic machinery -- specification compilation, product game construction, attractor computation, and winning-region extraction -- is better read as a design-time analytical instrument whose outputs are structural insights about a system rather than runtime constraints on a deployed agent. We instantiate this through a constrained two-player safety game for network defense. The two specifications are enforced asymmetrically: the defender specification defines the unsafe region of the game, whereas the attacker specification restricts the adversary's legal actions during attractor computation. Solving the game yields a defensibility verdict -- a formal certificate that a topology-specification pair is or is not defensible -- with the associated winning region and shield. Beyond the binary verdict, we derive topology-level metrics from the attractor structure and combine them with post-convergence behavior from shield-constrained adversarial multi-agent reinforcement learning. Together these form a defensibility fingerprint capturing both a network's formal safety properties and its operational behavior under adaptive play. A what-if analysis shows that formal defensibility and operational effectiveness capture distinct aspects of security: small architectural changes can produce large shifts in operational outcomes while leaving formal safety margins nearly unchanged. Shield synthesis is thus most valuable not as a deployment mechanism for safe agents, but as a framework for answering architectural questions about whether, where, and how a system can be defended. The defensibility verdict is the output, not the safe policy.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

83,970 characters extracted from source content.

Expand or collapse full text

Beyond Runtime Enforcement: Shield Synthesis as Defensibility Analysis for Adversarial Networks Achraf Hsain Sultan Almuhammadi Information and Computer Science Department King Fahd University of Petroleum and Minerals Dhahran Saudi Arabia g202518970, muhamadi@kfupm.edu.sa Abstract Shielded reinforcement learning is typically presented as a runtime safety mechanism: temporal-logic specifications are compiled into automata that restrict an agent’s actions to guarantee safe behavior. We argue that this is the wrong product. The same automata-theoretic machinery—specification compilation, product game construction, attractor computation, and winning-region extraction—is more naturally viewed as a design-time analytical instrument whose outputs are structural insights about a system rather than runtime constraints on a deployed agent. We instantiate this perspective through a constrained two-player safety game for network defense. A defender safety specification defines the set of unacceptable outcomes, while an attacker specification imposes operational constraints on the adversary. The two specifications are enforced asymmetrically: the defender specification defines the unsafe region of the game, whereas the attacker specification restricts the adversary’s legal actions during attractor computation. Solving the resulting game produces a defensibility verdict—a formal certificate that a topology-specification pair is or is not defensible—as well as the associated winning region and shield. To move beyond a binary verdict, we derive a set of topology-level defensibility metrics from the attractor structure and combine them with post-convergence behavior from shield-constrained adversarial multi-agent reinforcement learning. Together, these form a defensibility fingerprint that characterizes both the formal safety properties of a network and its operational behavior under adaptive attack and defense. A what-if analysis across topology and specification perturbations demonstrates that formal defensibility and operational effectiveness capture distinct aspects of security. In particular, small architectural changes can produce large shifts in operational outcomes while leaving formal safety margins nearly unchanged. The results suggest that shield synthesis is most valuable not as a deployment mechanism for safe agents, but as a framework for answering architectural questions about whether, where, and how a system can be defended. The defensibility verdict is the output, not the safe policy. Keywords: Shield synthesis, safety games, temporal logic, network defense, multi-agent reinforcement learning, defensibility analysis, formal methods. 1 Introduction A security architect responsible for a critical network segment faces a question current tools answer only partially: is this segment defensible? If so, how defensible—and which architectural changes would improve the margin? Static network verification tools [29, 30] verify reachability and isolation properties on fixed configurations but cannot model a strategic adversary. Reinforcement learning for cybersecurity [19, 21] trains adaptive agents against simulated attackers, but a trained policy that survives one adversary may fail against another, and no informal method certifies that a topology is fundamentally indefensible. Between static certainty and adaptive learning lies a gap: no existing tool produces a provable defensibility verdict—a formal certificate that a winning defense strategy exists, or does not—while quantifying the operational quality of that defense. Shielded reinforcement learning (ShRL) [1, 3, 2] offers a formal pipeline that, in principle, fills this gap. From a temporal logic safety specification, the pipeline compiles a deterministic finite automaton (DFA), constructs a product game with the system model, computes the winning region by attractor fixed-point iteration, and extracts a shield: a lookup table of permitted actions guaranteeing the specification is never violated. The machinery is exact, grounded in automata theory and game theory. The existing literature deploys this machinery as a runtime enforcement mechanism. The shield filters an RL agent’s actions during training or deployment, ensuring safety while the agent optimizes a reward signal [1, 3, 4]. This framing carries fundamental constraints, openly acknowledged in recent surveys of safe learning [4, 10]. Explicit-state synthesis grows exponentially in the number of state variables, confining tractable computation to small environments. The guarantee is model-bound—valid only under the assumed transition model, with no recourse for model mismatch or out-of-distribution states; the existence of automata-learning-based shielding [9] is itself recognition that deterministic shields cannot be deployed when the dynamics are not exactly known. Partial observability lies outside the explicit-state formulation; POMDP-shielding extensions [7, 8] exist but inherit strong abstraction assumptions and do not remove the offline scalability cost. Future work may relax some of these properties; under current methods, runtime enforcement remains viable only in small, fully-known, deterministic settings. 1.1 The reframing The same machinery that fails as a runtime enforcement mechanism succeeds as a design-time analytical instrument. The shift is in product, not method. The outputs—defensibility verdicts, winning region geometry, attractor structure, specification interaction—are not actions for an agent. They are formal answers to questions previously available only to informal intuition. Is this configuration defensible? How much operational room does the defender have? Where does the defense collapse? Which architectural changes improve defensibility? We do not dismiss M/M/1 queueing models because real servers are not strictly Poisson. The analytical bounds those models produce govern system behavior, and the structural insights transfer to systems whose dynamics are merely approximated by the assumptions. Shielded reinforcement learning admits the same reading. State spaces are small, environments are abstractions, and guarantees are exact within them. The structural insights—which specifications interact dangerously, which topological features dominate operational outcomes, which architectural changes improve margins—are mathematically sound and empirically informative for the regime they target. The same limitations land differently in the two framings. As runtime enforcement at deployment scale, model approximation is catastrophic: a shield computed on an imprecise model asserts safety where it does not hold, and the deployed agent acts on the false guarantee. The community’s pivot toward probabilistic and automata-learning-based shielding [5, 6, 9] is itself acknowledgment of this fragility—and arguably erodes the case for shielding in the first place. The hard-guarantee floor is what justified the LTL-to-DFA-to-product-game pipeline over reward shaping or constrained policy optimization. Once the guarantee becomes probabilistic, the rigorous machinery is preserved but the deliverable is harder to defend on its own terms: a probabilistic shield is a heavier instrument competing with lighter methods that scale to deployment without the explicit-state burden. As design-time analysis, the architect supplies the model, tunes its fidelity to need, reads the verdict, and retains full responsibility for the deployed system. An approximate model produces useful approximate insights, not a deployed failure. The structural limitations are identical in both readings. The consequences of operating under them are not. 1.2 Contributions We instantiate this analytical paradigm through the following contributions: 1. Dual-specification constrained safety game. We formulate a two-player safety game in which the defender’s safety objective (φD _D) and the attacker’s operational constraints (φA _A) are compiled into separate DFAs with asymmetric enforcement: φD _D seeds the attractor’s initial unsafe set, while φA _A filters the attacker’s successor set during attractor computation. The two specifications enter different stages of the safety game’s solution; the asymmetry is the architectural feature (Section 3). 2. Defensibility verdict as primary output. Rather than treating the winning region as an intermediate computation en route to shield extraction, we elevate it to the primary deliverable: a provable binary certificate that a topology-specification pair is or is not defensible, with the shield as a derived witness for the positive case (Section 4). 3. Six topology defensibility metrics and the defensibility fingerprint. We derive six metrics from the attractor shell decomposition and the post-convergence MARL behavior. Composed under a uniform danger-oriented axis convention, they form the defensibility fingerprint: a unified diagnostic artifact for comparing network configurations (Section 5). 4. Shielded adversarial MARL as topology diagnostic. We confine two minimax-Q learners to the winning region and use their post-convergence behavior—the defender dominance ratio—as a continuous topology diagnostic, not an agent performance metric (Section 6). 5. What-if analysis. We demonstrate the framework’s analytical power through five topology and specification perturbations, revealing that the formal safety game and the MARL layer capture fundamentally different aspects of defensibility, and that neither alone gives the full picture (Section 7). Our implementation, experiments, and topology data are publicly available.111https://github.com/AchrafHsain7/Bastion 2 Preliminaries This section recalls standard material from automata theory, game theory, and multi-agent reinforcement learning; we introduce no new concepts here. Definition 1 (Deterministic Finite Automaton [12]). A DFA is a quintuple =(Q,Σ,δ,q0,F)A=(Q, ,δ,q_0,F) with finite state set Q, finite input alphabet Σ , transition function δ:Q×Σ→Qδ:Q× → Q, initial state q0q_0, and set of accepting states F⊆QF Q. Definition 2 (Safety Automaton [12]). A safety automaton is a DFA used to recognize a property the system must always satisfy: a run is safe if and only if every state it visits belongs to F. We assume without loss of generality that the violating states are absorbing — for every q∉Fq∉ F and every σ∈Σσ∈ , δ(q,σ)∉Fδ(q,σ)∉ F — so that once a run leaves F it can never return and a safety violation is permanent. Linear temporal logic (LTL) safety formulas of the form □ψ \,ψ (“always ψ”) compile mechanically into safety automata [12]. When several safety properties must hold simultaneously, their automata are combined via synchronous product. Given DFAs 1=(Q1,Σ1,δ1,q0,F1)A_1=(Q_1, _1, _1,q_0,F_1) and 2=(Q2,Σ2,δ2,q0′,F2)A_2=(Q_2, _2, _2,q^ _0,F_2) over a common alphabet, 1⊗2=(Q1×Q2,Σ1×Σ2,δ⊗,(q0,q0′),F1×F2),δ⊗((q1,q2),σ)=(δ1(q1,σ),δ2(q2,σ)).A_1 _2= (Q_1× Q_2,\ _1× _2,\ _ ,\ (q_0,q^ _0),\ F_1× F_2 ), _ ((q_1,q_2),σ )= ( _1(q_1,σ),\, _2(q_2,σ) ). The product accepts a word iff both components do; for safety automata this gives L(1⊗2)=L(1)∩L(2)L(A_1 _2)=L(A_1)∩ L(A_2), so the product enforces both properties at once. Definition 3 (Safety Game [11]). A safety game is played on a game arena Γ=(V,VD,VA,E,v0) =(V,V_D,V_A,E,v_0), where (V,E)(V,E) is a directed graph, (VD,VA)(V_D,V_A) is a partition of V called the turn partition, and v0∈Vv_0∈ V is the initial position. We call the vertices positions and the edges moves, and we assume every position has at least one outgoing move so that plays are infinite. Player 0 (the defender) owns the positions in VDV_D; Player 1 (the attacker) owns those in VAV_A. The owner of the current position chooses an outgoing move. A safety objective is given by an unsafe set U⊆VU V: an infinite play is winning for Player 0 if and only if it never visits U. Definition 4 (Winning Region and Attractor [11]). The winning region ⊆VW V is the largest set of positions from which Player 0 has a strategy guaranteeing the safety objective: from every v∈v , Player 0 can ensure U is never visited, regardless of Player 1’s strategy. Its complement, the attractor Attr∗=V∖Attr^*=V , is the set of positions from which Player 1 can force a visit to U in finitely many moves, no matter how Player 0 plays. Attractor Computation. The attractor is computed as a least fixed point. Initialize Attr0=UAttr_0=U. At each iteration i: (1) add any Player 1 position v∉Attriv _i that has at least one successor in AttriAttr_i (the attacker needs only one path to danger); (2) add any Player 0 position v∉Attriv _i whose every successor lies in AttriAttr_i (the defender is lost only when all options are doomed). The process terminates at the least fixed point Attr∗Attr^* when no new positions are added. Complexity is O(|V|+|E|)O(|V|+|E|) [11, 12]. The positions added at iteration k form what we call the attractor shell Sk=Attrk∖Attrk−1S_k=Attr_k _k-1: positions exactly k optimal moves from violation. These shells carry structural information about the topology that we exploit for metric construction (Section 5). Minimax Q-Learning. In a two-player zero-sum Markov game [13], the two players’ rewards sum to zero. Minimax Q-learning maintains a separate Q-table per player and evaluates a successor state under the assumption that the opponent plays to minimize the player’s value. We use the cross-table update Qi(s,a)←Qi(s,a)+α[Ri+γ⋅(−maxa′⁡Qj(s′,a′))−Qi(s,a)],Q_i(s,a)← Q_i(s,a)+α [R_i+γ· (- _a Q_j(s ,a ) )-Q_i(s,a) ], where j denotes the opponent. This is the pure-action simplification of Littman’s minimax-Q, whose general form solves a matrix game at each state for the minimax value over mixed strategies; convergence of the latter to the Markov-game value is established under standard conditions [14]. Section 6 discusses the equilibrium status of the simplified update we actually run. Table 1: Notation used throughout the paper. Layer 1 metrics are deterministic functions of the game graph; the Layer 2 metric (DDR) is measured from post-convergence MARL behavior. Symbol Meaning Automata and specifications =(Q,Σ,δ,q0,F)A=(Q, ,δ,q_0,F) Deterministic finite automaton □ψ \,ψ LTL “always ψ” (safety) ⊗ Synchronous product of automata φD,φA _D,\ _A Defender / attacker specifications D,AA_D,\ A_A Defender / attacker automata Network and game model G=(V,E)G=(V,E) Network segment: hosts V, edges E ℋ=C,X,D,I,ZH=\C,X,D,I,Z\ Host statuses (Clean, Compromised, Detected, Isolated, Destroyed) =(S,s0,AD,A,δ)G=(S,s_0,A_D,A_A,δ) Network defense game Γ=(V,VD,VA,E,v0) =(V,V_D,V_A,E,v_0) Safety-game arena; VD,VAV_D,V_A turn partition U Unsafe set (safety objective) Safety-game solution W Winning region Attr∗Attr^* Attractor, V∖V AttrkAttr_k Attractor after iteration k; Attr0Attr_0 initial unsafe set Sk=Attrk∖Attrk−1S_k=Attr_k _k-1 Attractor shell at depth k kmaxk_ Deepest attainable shell Succ(v,a),Safe(v)Succ(v,a),\ Safe(v) Successor under a; shield-permitted actions at v Defensibility metrics (danger-oriented unless noted) ATK Attackability (Layer 1) SNK Sinking ratio (Layer 1) FRC Shield friction (Layer 1) STP Attractor steepness (Layer 1) MSV Mean steps to violation (Layer 1, safety-oriented; fingerprint axis VPX=1/(k¯−1)VPX=1/( k-1)) DDR Defender dominance ratio (Layer 2, safety-oriented; fingerprint axis ADR=1−DDRADR=1-DDR) k¯,H,pk k,\ H,\ p_k Mean shell depth; shell-distribution entropy; shell mass fraction Learning Qi(s,a)Q_i(s,a) Per-player Q-value; α rate, γ discount, RiR_i reward εmin _ Exploration floor nC,Nep,Tn_C,\ N_ep,\ T Clean-host count; episodes; steps per episode 3 Network Defense Game Framework 3.1 Network Model We model a critical network segment—a small, well-defined portion of a larger enterprise network containing high-value assets and clearly delineated connectivity. The segment is small enough for explicit-state analysis, but rich enough to exhibit non-trivial defensive dynamics. Definition 5 (Network Segment). A network segment is a directed graph G=(V,E)G=(V,E) where V is a set of hosts and E⊆V×VE V× V represents connectivity paths (firewall rules, service dependencies, or misconfigurations). Each host v∈Vv∈ V carries a status from ℋ=C,X,D,I,ZH=\C,X,D,I,Z\: Clean (C)—no attacker presence; Compromised (X)—attacker has access, defender unaware; Detected (D)—attacker has access, defender aware; Isolated (I)—disconnected by defender action; or Destroyed (Z)—taken offline by attacker action, recoverable by defender repair. The five-status model captures the essential phases of a network intrusion lifecycle: initial compromise, discovery by the defender, and the two responses available to each side (isolation by the defender, destruction by the attacker, with recovery possible from both via dedicated defender actions). The reference topology (Figure 3) consists of five hosts (|V|=5|V|=5) and six directed edges (|E|=6|E|=6). GW is the internet-facing gateway and the attacker’s entry point. Web is a public-facing web server behind the first firewall. WS is an internal workstation accessible from Web (via FW2) and, critically, from GW via a forgotten VPN configuration that bypasses the web server. DB is the database server, reachable from Web (port 3306) and WS (zone trust). BK is the backup server, reachable only from DB via SSH. The VPN bypass is the topology’s most dangerous feature: it lets the attacker reach the workstation in a single hop from the gateway, circumventing the intended defense perimeter. Definition 6 (Network Defense Game). A network defense game is a tuple =(S,s0,AD,A,δ)G=(S,s_0,A_D,A_A,δ) where: • S=ℋ|V|×D,AS=H^|V|×\D,A\: state space (host status vector × turn indicator). • s0s_0: initial state (one host compromised, all others clean, attacker moves first). • AD=Noop,Monitor,Isolate,Restore,FixA_D=\ Noop, Monitor, Isolate, Restore, Fix\: defender actions. • A=Noop,Spread,DestroyA_A=\ Noop, Spread, Destroy\: attacker actions. • δ:S×(A×V)→Sδ:S×(A× V)→ S: deterministic transition function. Each action targets one specific host. Monitor reveals whether a host is compromised (X → D). Isolate disconnects a host. Restore reconnects an isolated host to clean status. Fix repairs a destroyed host to clean. Spread propagates compromise from a compromised or detected neighbor to a clean target. Destroy takes a compromised or detected host offline (recoverable via Fix). Both players have a Noop action. Action terminology. Throughout this paper we distinguish four properties an action may carry: • Available: syntactically selectable from the agent’s action set at the current state. • Transition-effective: preconditions are met; δ produces a state change. • Specification-admissible: the action does not advance a monitoring automaton to a violating state. Relevant only for the attacker, via φA _A. • Shield-safe: the action keeps play within the winning region W. All |AD|×|V|=25|A_D|×|V|=25 defender actions and |A|×|V|=15|A_A|×|V|=15 attacker actions are always available. Transition-effectiveness, specification-admissibility, and shield-safety are properties of the action’s interaction with δ, the automata, and W, not of the action itself. The uniform action space simplifies the product construction and ensures the game graph has no dead ends. Spread direction. Spread targeting host h succeeds iff status(h)=Cstatus(h)=C and there exists u with status(u)∈X,Dstatus(u)∈\X,D\ and (u,h)∈E(u,h)∈ E. The transition semantics are summarized in Table 2. Table 2: Transition semantics. Each cell shows the resulting host status when the given action targets a host in the given current status. ∗Spread to Clean requires an adjacent compromised or detected neighbor on a directed edge (u,h)∈E(u,h)∈ E. C X D I Z Defender Actions Monitor C D D I Z Isolate I I I I Z Restore C X D C Z Fix C X D I C Attacker Actions Spread X∗ X D I Z Destroy C Z Z I Z 3.2 Dual Temporal Logic Specifications The framework employs two independent specifications compiled into DFAs, with fundamentally different enforcement roles. This asymmetric enforcement—not the dual specifications themselves—is the core architectural mechanism. 3.2.1 Defender Safety Specification Definition 7 (Defender Specification φD _D). φD:□¬(DB∈X,D,Z∧BK∈X,D,Z)∧□(active≥3) _D: \, (DB∈\X,D,Z\\; \;BK∈\X,D,Z\ )\; \; \,(active≥ 3) (1) where active(s)=|v∈V:status(v)∉I,Z|active(s)=|\v∈ V:status(v)∉\I,Z\\|. In plain terms: (1) the database and backup server are never simultaneously in a compromised, detected, or destroyed state, and (2) at least three hosts remain operational at all times. This is a conjunction of two safety properties, each compiled into a separate DFA: • D(1)A_D^(1): tracks how many of DB,BK\DB,BK\ are in a “bad” state (X,D,Z\X,D,Z\). Three states: q0q_0 (neither bad), q1q_1 (exactly one bad), violviol (both bad, absorbing). Accepts in q0,q1\q_0,q_1\. • D(2)A_D^(2): checks whether the active host count falls below 3. Two states: safesafe and violviol. Accepts in safe\safe\. The product D=D(1)⊗D(2)A_D=A_D^(1) _D^(2) has |QD|=6|Q_D|=6 states with |FD|=2|F_D|=2 accepting states: (q0,safe)(q_0,safe) and (q1,safe)(q_1,safe). The remaining four states represent violation of at least one safety clause. q0q_0q1q_1viol01101122220,1,20,1,2 (a) D(1)A_D^(1) safeviolactive≥3active\!≥\!3active<3active\!<\!3⊤ (b) D(2)A_D^(2) Figure 1: The two defender safety automata composing D=D(1)⊗D(2)A_D=A_D^(1) _D^(2) for φD _D (Definition 7). (a) reads the number of critical assets DB,BK\DB,BK\ currently bad (∈X,D,Z∈\X,D,Z\): q0q_0 none, q1q_1 exactly one, viol both. (b) reads whether at least three hosts remain active. Double circles are accepting; shaded circles are absorbing violation sinks (⊤ == any input). 3.2.2 Attacker Constraint Specification Definition 8 (Attacker Specification φA _A). φA _A: at most 2 Destroy actions per engagement. Compiled into DFA AA_A with |QA|=4|Q_A|=4 states tracking the destroy count, accepting in q0,q1,q2\q_0,q_1,q_2\. We treat Destroy as consuming attacker budget by intent rather than by effect: AA_A advances on every Destroy action selected by the attacker, including Destroy on already-isolated or already-destroyed hosts that produce no state change. This is a deliberate modeling choice that prices attempted destruction the same as successful destruction. Charging only effective destroys would yield a successful-damage threat model in which an attacker incurs no penalty for failed attempts; the intent-based pricing here matches a threat model in which attacker effort, not just attacker success, is the binding resource. The destroy budget is scoped to a single engagement. As detailed in Section 6.4, when all hosts are clean the attacker respawns and AA_A resets. φA _A is therefore an engagement-level resource constraint, not a global infinite-trace property over the full training horizon. q0q_0q1q_1q2q_2viol¬D D¬D D¬D D⊤ Figure 2: Attacker constraint automaton AA_A for φA _A (Definition 8): at most two Destroy actions per engagement. D == Destroy, ¬D D == any non-Destroy action, ⊤ == any input; qiq_i records i Destroys spent. AA_A advances on every Destroy the attacker selects—including no-op Destroys—so attempted destruction is priced like successful destruction. 3.2.3 Asymmetric Enforcement The two specifications serve fundamentally different roles in the safety game: • φD _D defines the safety objective. A play is safe iff DA_D remains in an accepting state at every step. Product states where qD∉FDq_D∉ F_D seed the attractor’s initial unsafe set U. • φA _A constrains the attacker’s strategy space. The attacker’s moves at each state are filtered to those keeping AA_A in an accepting state, enforced via the Legal(v)Legal(v) function in the attractor computation. The asymmetry is non-trivial. Seeding attacker-violation states into U would be incorrect: the attacker can always choose to violate its own constraints (by issuing a third Destroy), so every attacker state would have a successor in U, and the attractor would absorb the entire state space. The correct design uses φD _D to define what must never happen and φA _A to define what the attacker cannot do. These are two different enforcement mechanisms, not two instances of one. Comparison with related architectures. Reactive synthesis with environment assumptions [17, 18] wires environment behavior into the synthesis objective as an implication: env satisfies A → sys satisfies G. The two specifications collapse into a single synthesis target. Multi-agent shielding [15, 16] shields cooperative agents under a shared specification. The architecture used here—two players, two independent automata, two enforcement mechanisms entering different stages of the safety game’s solution—composes differently. φD _D seeds the unsafe set; φA _A filters the attacker’s successors during attractor computation. Each automaton modifies a different stage of the fixed-point iteration, and the resulting winning region depends on both. The cyber-defensibility diagnostic use of this dual-specification, asymmetric-enforcement architecture has not been developed in prior ShRL or reactive synthesis work. 3.3 Product Game Construction The product game combines the network defense game with both DFA specifications, creating a single game graph in which every state simultaneously tracks the network configuration, the current turn, the defender’s safety status, and the attacker’s constraint status: s×=(status(v1),…,status(v|V|)⏟host statuses,τ⏟turn,qD⏟D,qA⏟A)s_×= ( status(v_1),…,status(v_|V|)_host statuses,\ τ_turn,\ q_D_A_D,\ q_A_A_A ) (2) where S×S_× denotes the set of all such product states. 3.3.1 A short play To make the product state concrete, we trace four moves from the initial configuration. Each row shows the state after the indicated action: the host-status vector ⟨GW,Web,WS,DB,BK⟩ ,Web,WS,DB,BK , the turn τ (next to move), and the two automaton states qD=(q(1),q(2))q_D=(q^(1),q^(2)) and qAq_A. Status codes are C/X/D/I/Z as in Table 2. # Action ⟨GW,Web,WS,DB,BK⟩ ,Web,WS,DB,BK τ D(1)A_D^(1) D(2)A_D^(2) AA_A 0 initial state XCCCCX\,C\,C\,C\,C A q0q_0 safe q0q_0 11 Attacker: Spread(WS) XCXCCX\,C\,X\,C\,C D q0q_0 safe q0q_0 22 Defender: Monitor(WS) XCDCCX\,C\,D\,C\,C A q0q_0 safe q0q_0 33 Attacker: Spread(DB) XCDXCX\,C\,D\,X\,C D q_1 safe q0q_0 44 Defender: Isolate(DB) XCDICX\,C\,D\,I\,C A q_0 safe q0q_0 The play reads as follows. The attacker enters at the gateway (GW=XGW=X) and uses the VPN-bypass edge to compromise the workstation in a single hop (move 1), sidestepping the web server. The defender monitors WSWS, converting the silent compromise into a detected one (X→DX\!→\!D, move 2). The attacker then pivots to the database over the zone-trust edge (move 3): now one critical asset is bad, so D(1)A_D^(1) advances q0→q1q_0\!→\!q_1 (cf. Figure 1a). The state is still accepting—φD _D is violated only when both critical assets are bad simultaneously—so it is not yet in U. The defender isolates DBDB (move 4), pulling it out of the bad set X,D,Z\X,D,Z\; D(1)A_D^(1) recovers q1→q0q_1\!→\!q_0, exactly the q1→q0q_1\!→\!q_0 edge of Figure 1a. Throughout, D(2)A_D^(2) stays safe (active count never drops below three) and AA_A stays q0q_0, since AA_A advances only on a Destroy and none was issued. This illustrates the two enforcement inputs of Section 3.2.3: DA_D consumes the world consequence (the new status vector), while AA_A consumes the attacker’s intent (the action label). Transitions in the product game are derived mechanically. When an action is taken in network state s producing successor s′s , the defender automaton DA_D advances by consuming the label of s′s (the propositions extracted from the new network state), while the attacker automaton AA_A advances based on the action taken (whether a Destroy was issued, regardless of effect). The asymmetry of inputs reflects the asymmetry of enforcement: φD _D monitors world consequences, φA _A monitors agent intentions. For the reference topology with |V|=5|V|=5, |ℋ|=5|H|=5, |QD|=6|Q_D|=6, |QA|=4|Q_A|=4, : |S×|=55×2×6×4=150,000|S_×|=5^5× 2× 6× 4=150,000 (3) The product state space is the Cartesian product of its components, so |S×||S_×| is the product of their sizes. Of these 150,000 product states, exactly 100,000 figure counts states already violating φD _D — those with qD∉FDq_D∉ F_D — independent of any game dynamics and constitute the initial unsafe set Attr0Attr_0. The remaining 50,000 candidate states are partitioned by the attractor computation into the winning region W and the non-trivially-unsafe states absorbed during fixed-point iteration. 4 Safety Game Solution 4.1 Attractor Computation with Dual Specifications The attractor computation follows the standard fixed-point algorithm (Section 2), with one critical modification: the attacker’s successors are filtered through Legal(v)Legal(v), which returns only transitions that do not violate φA _A. Algorithm 1 Attractor Computation with Constrained Adversary 1:Game graph G×G_×, unsafe set U=v:qD∉FDU=\v:q_D∉ F_D\ 2:Attr0←UAttr_0← U 3:repeat 4: for each attacker vertex v∈VA∖Attriv∈ V_A _i do 5: if ∃v′∈Legal(v)∩Attri∃\,v (v) _i then ⊳ ∃-quantifier 6: Attri+1←Attri+1∪vAttr_i+1 _i+1∪\v\ 7: end if 8: end for 9: for each defender vertex v∈VD∖Attriv∈ V_D _i do 10: if ∀v′∈Succ(v),v′∈Attri∀\,v (v),\ v _i then ⊳ ∀-quantifier 11: Attri+1←Attri+1∪vAttr_i+1 _i+1∪\v\ 12: end if 13: end for 14:until Attri+1=AttriAttr_i+1=Attr_i 15:return ←(VD∪VA)∖Attr∗W←(V_D∪ V_A) ^* The asymmetry of the quantifiers is essential. An attacker vertex enters the attractor if any legal successor is already there: the attacker needs only one path to danger. A defender vertex enters only if every successor is in the attractor: the defender is lost only when every option is doomed. The constrained adversary is a strict refinement of the standard formulation—fewer attacker successors means a smaller attractor, which means a larger winning region. 4.2 Defensibility Verdict Definition 9 (Defensibility). A network defense game G with specifications φD,φA _D, _A is defensible iff the initial product state s0,×∈s_0,× . This is the framework’s primary output. The shield—the table of safe actions per winning state—is a derived artifact: a witness to the verdict’s positive case. The verdict is what answers the architect’s question. When positive, W identifies exactly which configurations admit a safe defense strategy. When negative, the framework certifies that no defense exists from the initial configuration: a formal negative result that no policy training, however thorough, can produce. A failed RL run leaves the architect in epistemic limbo—was the reward shaped poorly, was training under-resourced, or is the problem inherently indefensible? The verdict resolves this ambiguity by construction. For the reference topology, the attractor converges in 4 iterations: Iteration |Attrk||Attr_k| Shell |Sk||S_k| Attr0Attr_0 (initial violations) 100,000 — Attr1Attr_1 123,230 23,230 Attr2Attr_2 125,630 2,400 Attr3Attr_3 (fixed point) 126,270 640 Winning region |||W| 23,730 (15.82% of |S×||S_×|) The initial product state s0,×∈s_0,× . The reference topology is defensible. The rapid convergence (three non-trivial iterations) and the steep concentration of absorbed states in shell 1 (23,230 of 26,270 total, or 88.4% ) characterize a “cliff” topology: most vulnerable states are a single misstep from violation (23,230 states are one optimal move from violation (shell 1), only 2,400 are two moves away (shell 2)). Remark 1 (Trivial indefensibility.). Consider a degenerate specification φD′:□(∀v∈V,status(v)=C) _D : (∀ v∈ V,\ status(v)=C ) requiring every host to remain Clean at all times. The initial state s0s_0 already has one host compromised by construction, so s0,×∉FDs_0,×∉ F_D and s0,×∈Attr0s_0,× _0 before any iteration begins. The verdict is indefensible immediately: Safe(s0,×)=∅Safe(s_0,×)= , no defender action from the initial state avoids violation. The pipeline reports the impossibility in a single graph-theoretic step, without conflating it with an under-trained policy or a poorly-shaped reward. 4.3 Shield Extraction For each product state v∈v , the shield computes the set of safe actions: Safe(v)=a:Succ(v,a)∉Attr∗if v∈VDa:Succ(v,a)∉Attr∗∧qA′≠violif v∈VASafe(v)= cases\a:Succ(v,a) ^*\&if v∈ V_D\\ \a:Succ(v,a) ^*\; \;q_A \&if v∈ V_A cases (4) Both agents are constrained to remain within W. The attacker is additionally prevented from violating φA _A. The shield serves a role that differs from its function in standard ShRL: it does not protect a learning agent from making unsafe moves—it defines the arena within which two adversarial agents will compete. Neither agent can leave the winning region, and the attacker cannot exceed its engagement-level resource budget. The subsequent MARL analysis (Section 6) takes place entirely within this formally bounded arena, guaranteeing that every trajectory observed during training satisfies both φD _D and φA _A by construction. The contribution of the pipeline is the verdict and the winning region. The shield is what the verdict produces. 5 Topology Defensibility Metrics The verdict is binary. The architect needs more—a quantitative profile of how defensible a configuration is, where its weaknesses concentrate, and how its operational character compares to alternatives. We derive six metrics from the attractor shell decomposition (Section 4) and the post-convergence MARL behavior (Section 6). Composed on a radar chart, they form a defensibility fingerprint: a visual signature of a topology-specification pair. Throughout, we refer to the safety-game-derived quantities (ATK, SNK, FRC, STP, MSV) as Layer 1 metrics—properties of the formal game graph, deterministic in the model—and to the post-convergence MARL behavior (DDR) as the Layer 2 metric, capturing operational behavior under adaptive play within the shield-bounded arena. The two-layer terminology is used throughout the metrics, the analysis, and the discussion. Orientation convention. The first five metrics use raw expressions in which higher values indicate greater danger. The last two raw quantities (Mean Steps to Violation, Defender Dominance Ratio) are higher-is-safer; for the fingerprint we transform them into danger-oriented forms (Violation Proximity, Attacker Dominance Ratio). Table 3 summarizes both conventions. Table 3: Metric orientation. Raw quantities and the danger-oriented forms used in the defensibility fingerprint. Metric Symbol Raw orientation Fingerprint axis Attackability ATK higher = more dangerous ATK Sinking Ratio SNK higher = more dangerous SNK Shield Friction FRC higher = more dangerous FRC Attractor Steepness STP higher = more dangerous STP Mean Steps to Violation MSV higher = safer VPX =1/(MSV−1)=1/(MSV-1) Defender Dominance Ratio DDR higher = safer ADR =1−DDR=1-DDR Conceptual versus empirical independence. The six metrics are conceptually distinct functionals of the attractor decomposition and the post-convergence MARL behavior: ATK measures attack-edge-weighted boundary exposure, SNK measures absorbed-state interior mass, FRC measures shield-induced action-space restriction, STP and MSV summarize the shell-distribution shape under opposite orientations, and DDR captures operational behavior under adversarial play. Conceptual distinctness does not imply empirical independence within any given regime. As reported in Appendix A, in the cyber-defensibility regime explored here, ATK, SNK, and FRC reveal a single dominant compromise-pressure axis (pairwise r≥0.985r≥ 0.985 across the five cases); STP and MSV are essentially perfectly anti-correlated (r=−1.000r=-1.000) as small-support shell distributions in this regime; and DDR is structurally orthogonal to all five formal metrics (|r|≤0.54|r|≤ 0.54). The empirical collapse from six conceptually distinct projections to approximately three effective axes in this regime is itself a structural finding. The DDR-orthogonality, in particular, empirically validates the two-layer decoupling that motivates the framework: operational outcomes cannot be inferred from any subset of formal metrics, and the fingerprint’s value lies in displaying both the formal and operational signals on the same diagnostic surface. 5.1 Attackability A weighted measure of how exposed the winning region is to attractor proximity: ATK=1||∑k=1kmaxγk⋅|Sk|ATK= 1|W| _k=1^k_ γ^k·|S_k| (5) where γ∈(0,1)γ∈(0,1) is the discount factor, set equal to the RL agent’s discount factor to bridge topological danger and the agent’s temporal horizon. Normalization by |||W| measures threat density relative to the defender’s operational space. Values exceeding 1.0 indicate weighted threat mass exceeding the safe state count. When independence from MARL hyperparameters is preferred, a linear weight wk=1−k/kmaxw_k=1-k/k_ provides an alternative geometric interpretation tied purely to the attractor structure. 5.2 Sinking Ratio The fraction of initially non-violating states absorbed into the attractor: SNK=|Attr∗|−|Attr0||S×|−|Attr0|SNK= |Attr^*|-|Attr_0||S_×|-|Attr_0| (6) SNK measures how many states that were not initially in violation were nevertheless pulled into the unsafe region by the attacker’s strategic reach. High sinking indicates that the attacker’s power extends far beyond the immediate violation boundary. 5.3 Shield Friction FRC=∑v∈∩VD(|AD×V|−|Safe(v)|)∑v∈∩VD|AD×V|FRC= _v ∩ V_D (|A_D× V|-|Safe(v)| ) _v ∩ V_D|A_D× V| (7) The fraction of defender actions the shield must block across all defender states in W. High friction means the defender is topologically cornered: the shield masks a large fraction of the policy space to maintain safety. FRC has no direct analogue in either the shield-synthesis or the network-security-metrics literature (Section 8); it bridges the two by quantifying the operational cost of formal safety. 5.4 Attractor Steepness For a winning-region attractor with shells S1,…,SkmaxS_1,…,S_k_ , let pk=|Sk|/(|Attr∗|−|Attr0|)p_k=|S_k|/(|Attr^*|-|Attr_0|) denote the fraction of non-trivially-unsafe state mass at attractor depth k. The Shannon entropy of this depth distribution, H=−∑k:|Sk|>0pkln⁡pk,H=- _k:\,|S_k|>0p_k p_k, (8) attains its maximum Hmax=ln⁡kmaxH_ = k_ when shell mass is uniformly spread across all attainable depths and is minimized (zero) when all mass concentrates at a single depth. Steepness is defined as the normalized entropy deficit, STP=1−Hln⁡kmaxif kmax≥2,1if kmax=1,STP= cases1- H k_ &if k_ ≥ 2,\\[4.0pt] 1&if k_ =1, cases (9) yielding STP∈[0,1]STP∈[0,1]. STP near 11 indicates a cliff: the unsafe shell mass concentrates at a single attractor depth, and the dangerous region presents the attacker with forced-violation moves of essentially uniform length. STP near 0 indicates a gentle slope: the mass is spread evenly across all attainable depths, and the dangerous region exhibits a wide variety of forcing-distance values. Steepness is a measure of distributional shape over depth. Where ATK weights shell mass by depth-discounted volume and MSV summarizes depth as a first moment, STP is invariant to total attractor volume and to depth-weighted volume; it isolates concentration versus spread. The three quantities thus diagnose distinct facets of the attractor’s geometry rather than redundant projections of the same one. The metric does retain a normalization-base dependence on kmaxk_ : a deeper attractor with the same relative shape is normalized against a larger ln⁡kmax k_ , so absolute STP comparisons across attractors of differing depth should be read with this in mind. Within a what-if comparison whose cases share comparable attractor depths—as in our experimental evaluation—this dependence is benign. 5.5 Violation Proximity VPX=1k¯−1,k¯=∑k=1kmaxk⋅|Sk|∑k=1kmax|Sk|VPX= 1 k-1, k= _k=1^k_ k·|S_k| _k=1^k_ |S_k| (10) The reciprocal of the shifted mean attractor depth. Since k¯≥1 k≥ 1 by construction, subtracting 1 before inversion amplifies small variations that would otherwise cluster near 1. High VPX indicates that, on average, vulnerable states lie very close to the violation boundary. 5.6 Attacker Dominance Ratio ADR=1−DDRADR=1-DDR (11) where the Defender Dominance Ratio (DDR) is the average fraction of clean hosts at the post-convergence MARL behavior (Section 6). ADR bridges the formal safety game (Layer 1) and the operational layer (Layer 2): how much of the network the attacker controls when both agents play optimally within the shield’s constraints. 5.7 The Defensibility Fingerprint The six danger-oriented axes plotted on a radar chart produce a visual signature of a topology-specification pair (Figure 4). Each axis is independently min-max scaled to the range observed across the cases jointly compared. This makes shape differences across cases meaningful but renders a single fingerprint uninterpretable in isolation: the axes have no absolute units, and a fingerprint extracted from one comparison set cannot be overlaid on a fingerprint from another. Adding a new case in principle requires regenerating the full set under a common rescaling. The fingerprint is a comparative diagnostic for a fixed set of configurations under joint analysis, not a portable absolute score. Within that scope it integrates formal game-theoretic analysis (five Layer 1 axes) with operational assessment (one Layer 2 axis) into a single artifact the architect can read at a glance. 6 Shielded Adversarial MARL 6.1 Purpose The safety game answers a binary question: can the defender survive? It does not answer: how well can the defender survive? Two topologies may have identically-sized winning regions yet differ dramatically in operational difficulty—one may offer the defender many safe options at each step, while the other forces a narrow, precarious path. The MARL layer resolves this by placing two adaptive agents inside the winning region and observing what happens when both compete under the shield’s constraints. The design inverts the standard ShRL relationship between the shield and the RL agent. In conventional ShRL, the agent is the primary system and the shield is its safety filter. Here, the shield is the primary analytical output (defining W and the defensibility verdict), and the agents are diagnostic instruments whose post-convergence behavior reveals topology properties the safety game alone cannot capture. The game is played entirely within W: the shield defines the arena, not a guardrail. 6.2 Zero-Sum Reward The reward must incentivize meaningful engagement within the shield’s constraints. Inside W no trajectory can reach a φD _D-violating state by construction, so any reward triggered by violation is structurally vacuous and produces no learning signal. Asymmetric per-status rewards—defender accruing +1+1 per Clean host, attacker +1+1 per Compromised host—were tried and rejected: under shielded action sets they admit a degenerate cooperative equilibrium in which both agents settle on a locally favorable configuration and Noop indefinitely, each collecting their own positive signal without engaging the other. Per-status reward without an opposing pressure does not produce adversarial play. We adopt a tug-of-war zero-sum formulation that rewards the degree of network control: RD(s)=nC(s)−n¬C(s)|V|,RA(s)=−RD(s)R_D(s)= n_C(s)-n_ C(s)|V|, R_A(s)=-R_D(s) (12) where nC(s)n_C(s) is the number of clean hosts and n¬C(s)=|V|−nC(s)n_ C(s)=|V|-n_C(s). The range is [−1,+1][-1,+1]. When cleanliness drops below 50%, the defender receives continuous negative reward at every step, creating persistent pressure to reclaim hosts rather than accept a degraded equilibrium. The attacker is symmetrically motivated to push cleanliness below 50% and hold it there. The reward transforms the shielded game from a stalemate into a tug-of-war whose post-convergence point is informative about the topology’s operational balance. 6.3 Minimax Q-Learning with Shield Constraints Two separate Q-tables QAQ_A and QDQ_D are updated with cross-table minimax lookup: QA(s,a) Q_A(s,a) ←QA(s,a)+α[RA+γ(−maxa′∈Safe(s′)⁡QD(s′,a′))−QA(s,a)] ← Q_A(s,a)+α [R_A+γ(- _a (s )Q_D(s ,a ))-Q_A(s,a) ] (13) QD(s,a) Q_D(s,a) ←QD(s,a)+α[RD+γ(−maxa′∈Safe(s′)⁡QA(s′,a′))−QD(s,a)] ← Q_D(s,a)+α [R_D+γ(- _a (s )Q_A(s ,a ))-Q_D(s,a) ] (14) The Safe(⋅)Safe(·) constraint ensures both the minimax lookahead and actual action selection respect the shield. The attacker’s safe action set includes both the winning-region constraint and the φA _A admissibility check; the defender’s includes only the winning-region constraint (defender violations are already captured in Attr0Attr_0). On equilibrium and convergence. The classical minimax-Q convergence result [14] requires that both agents visit all state-action pairs infinitely often and that learning rates decay appropriately. The shield-restricted action sets and the persistent εmin=0.1 _ =0.1 exploration floor used here satisfy the structural conditions under which the result is invoked, but not its formal hypotheses. We use “equilibrium” descriptively—for the post-convergence shield-constrained behavior we observe and report—rather than as a formal Nash claim. The empirical signal is consistent with what one would expect of an equilibrium in this restricted game: tight inter-seed confidence intervals (Section 7), stable L200 dominance ratios, and reproducible per-case operating points. Whether the post-convergence behavior is the unique Nash of the restricted game is a question we do not resolve here. Table 4 summarizes the training configuration. Table 4: MARL training hyperparameters. Parameter Value Learning rate α 0.05 Discount factor γ 0.95 Initial exploration ε 0.5 Exploration decay Linear to 0.1 over training Minimum ε 0.1 Episodes 3,000 Steps per episode 1,000 Seeds per case 10 (seeds 1–10) Confidence level 95% (Student’s t) 6.4 Respawn and Engagement-Level φA _A When all hosts are clean, a new attacker engagement begins: the attacker respawns at the gateway with probability p=0.1p=0.1, and both automata (DA_D and AA_A) reset to their initial states. The mechanism is an episodic reset for infinite-horizon MARL training, not a transition rule of the underlying network model. It models a sequence of independent intrusion attempts—each with its own bounded resource budget—rather than one endless engagement. Without the reset, the destroy budget would persist across the infinite-horizon game, exhausting in the first few episodes and artificially inflating dominance ratios for the remaining training. φA _A is therefore a per-engagement resource constraint: the constraint binds within a single intrusion attempt, and a respawn begins a new one. On apparent respawn bias. A reader may worry that respawn after a fully-cleaned network grants the defender a window of free positive reward and inflates DDR. The reward structure prevents this. Pre-emptive isolation of the gateway in anticipation of respawn would convert a Clean host into Isolated, reducing nCn_C and incurring negative reward—exactly as in operation, where pre-emptive disconnection costs availability. Defenders converge on monitoring and containment rather than disconnection, matching the intended modeling of isolation as an emergency action and not a default posture. 6.5 Defender Dominance Ratio Definition 10 (Defender Dominance Ratio). DDR=1Nep⋅T∑e=1Nep∑t=1TnC(se,t)|V|DDR= 1N_ep· T _e=1^N_ep _t=1^T n_C(s_e,t)|V| (15) We report the L200 variant, averaging over the final 200 episodes after convergence to capture post-training behavior rather than transient learning dynamics. The DDR is not an agent performance metric. It is a property of the topology-specification pair revealed by adaptive play under formal constraints. Different topologies produce different operating points. The narrow inter-seed confidence intervals reported in Table 6 (all five 95% intervals span fewer than three percentage points, with the baseline at [52.4,55.3][52.4,55.3] being the widest and Case 3 the tightest at [47.2,47.9][47.2,47.9]) support this reading: the operating point is determined by the topology-specification pair, not by training stochasticity. 7 Experimental Evaluation 7.1 Reference Topology The reference topology is a 5-node network segment with V=GW,Web,WS,DB,BKV=\GW,Web,WS,DB,BK\ and 6 directed edges, including a VPN bypass path from GW to WS representing a forgotten configuration (Figure 3). GW is internet-facing; DB and BK are critical assets protected by φD _D. GWWebWSDBBKFW1FW2p3306zoneSSHVPN bypass Figure 3: Reference topology. 5 nodes, 6 directed edges. Dashed red edge: VPN bypass path from the gateway to the workstation, representing a forgotten VPN configuration that lets the attacker bypass the web server entirely. GW is internet-facing (attacker entry point); DB and BK are the critical assets protected by φD _D. 7.2 What-If Cases To demonstrate the framework’s analytical power, we evaluate five configurations (Table 5). Cases 2 and 5 perturb the topology; Cases 3 and 4 perturb the specifications. Table 5: What-if analysis configurations. Case Type Description 1 Baseline Reference topology, φD _D: no dual-critical-asset failure ∧ active ≥3≥ 3, φA _A: ≤2≤ 2 destroys per engagement 2 Topology Fully connected: bidirectional edges between all non-BK hosts; BK reachable only from DB. Directed-edge count rises from 6 to 13. 3 Specification Relaxed φA _A: unlimited Destroy actions. The attacker counter automaton is retained for product-state comparability, with all destroy-count states accepting; |S×||S_×| remains 150,000. 4 Specification Relaxed φD _D: active ≥2≥ 2 instead of ≥3≥ 3 5 Topology VPN bypass edge removed 7.3 Statistical Design All MARL results are averaged over n=10n=10 independent seeds (1–10). We report the Defender Dominance Ratio using the L200 variant to capture post-convergence behavior rather than transient dynamics. Confidence intervals are computed using the Student’s t-distribution at the 95% level: CI=x¯±tn−1,0.025⋅snCI= x± t_n-1,0.025· s n (16) where x¯ x is the sample mean, s is the sample standard deviation, and t9,0.025=2.262t_9,0.025=2.262. Each seed runs 3,000 episodes of 1,000 steps, yielding 3×1063× 10^6 state transitions per seed and 3×1073× 10^7 per case. The safety game metrics (ATK, SNK, FRC, STP, MSV) are deterministic—they depend only on the game graph and are identical across seeds. Computational cost. The framework runs on commodity consumer hardware. With an optimized attractor implementation, fixed-point computation is effectively instantaneous; successor-graph construction takes approximately five seconds per case; one MARL training run (3,000 episodes × 1,000 steps) completes in 50 seconds; total wall time across all five cases at ten seeds each is under one hour. These numbers are not a benchmark claim. They make the structural point that for the regime this paper targets—small subsystems whose formal analysis informs architectural decisions—computational cost is not the binding constraint. 7.4 Results Table 6 presents the complete what-if comparison. Raw orientations are reported; danger-oriented forms (VPX, ADR) are used for the radar fingerprints in Figure 5. Table 6: What-if comparison of topology defensibility metrics. ATK, SNK, FRC, STP are danger-oriented; MSV and DDR are safety-oriented (transformed for the fingerprint, see Table 3). |||W| = winning region size, W% = ||/|S×||W|/|S_×|, DDR = Defender Dominance Ratio (L200, 10-seed mean), CI = 95% confidence interval. Case Description ATK SNK FRC STP MSV |||W| W% DDR 95% CI 1 Baseline 1.044 0.525 0.613 0.620 1.140 23,730 15.8% 53.9% [52.4, 55.3] 2 Fully connected 1.080 0.534 0.618 0.620 1.139 23,310 15.5% 22.7% [21.6, 23.7] 3 Unlimited destroys 1.352 0.589 0.640 0.558 1.173 20,526 13.7% 47.5% [47.2, 47.9] 4 Relaxed φD _D 0.446 0.321 0.516 0.657 1.119 33,966 22.6% 77.9% [77.4, 78.3] 5 VPN removed 1.034 0.523 0.613 0.635 1.131 23,858 15.9% 80.7% [79.4, 82.1] 7.5 Defensibility Fingerprints Figure 4 shows the baseline defensibility fingerprint, and Figure 5 compares all five cases. Each axis is independently scaled to the range observed across the cases under comparison. Figure 4: Defensibility fingerprint for the baseline topology (Case 1). Six axes oriented so that points further from the center indicate greater danger. Each axis is independently scaled. Figure 5: Defensibility fingerprints for all five what-if cases. Topology perturbations (Cases 2 and 5) produce dramatically different fingerprints despite similar safety game metrics. Specification perturbations (Cases 3 and 4) reshape the fingerprint coherently across both layers. Each axis is independently scaled to the range observed across the five cases; shape comparisons are meaningful, absolute area is not an absolute vulnerability score. 7.6 State Space Decomposition Figure 6 shows the winning region and attractor shell distribution across cases. The stacked bars decompose the candidate state space (states not in initial violation) into the winning region and attractor shells by depth. Figure 6: Winning state space decomposition across what-if cases. Green: winning region (safe states). Yellow/red: attractor shells by depth (states absorbed during fixed-point computation). Case 4 (relaxed φD _D) produces the largest winning region; Case 3 (unlimited destroys) the smallest. 7.7 Dominance at Equilibrium Figure 7 presents the post-convergence DDR distribution across 10 seeds per case, with box plots and 95% confidence intervals. Figure 7: Defender Dominance Ratio at post-convergence (L200) across what-if cases. Each point is one seed (n=10n=10); boxes show interquartile range; whiskers extend to 1.5 IQR. Dashed line at 50% marks even split. Case 2 (fully connected) collapses to 22.7% despite near-identical safety game metrics to the baseline. 7.8 Analysis Three principal findings emerge. Finding 1: The two layers decouple under topology perturbation. Cases 2 and 5 are the clearest illustration of two-layer decoupling. Both have safety game metrics nearly indistinguishable from the baseline: |||W| differs by less than 3%, ATK by less than 4%, STP within 3%. Yet their operational outcomes diverge by an order of magnitude—DDR of 22.7% versus 80.7%. In Case 2 (fully connected), the directed-edge count rises from 6 to 13. The added edges give the attacker substantially more spread opportunities. The safety game, which asks “can the defender survive against any legal attacker strategy?”, sees a nearly identical winning region. The MARL layer, which asks “what happens when both agents play adaptively?”, reveals that the attacker exploits the connectivity to dominate the network. The topology is formally defensible—no attacker strategy can simultaneously breach both critical assets and reduce the active host count below three—but operationally overwhelmed. In Case 5 (VPN bypass removed), a single edge—barely visible to the formal safety metrics, dominant in the operational layer—is the difference between a contested 54% and a comfortable 81% defender dominance. The framework produces precisely the insight the architect needs: a single forgotten firewall rule does not change whether a defense exists, but it changes whether that defense actually succeeds against an adaptive adversary. Neither layer alone provides this picture. A system using only the safety game would report Cases 2 and 5 as near-baseline winning regions (||/|S×||W|/|S_×| of 15.5% and 15.9% respectively, vs. the baseline’s 15.8%) and miss the operational gap. A system using only MARL would lack the formal guarantee that safety is achievable at all. Finding 2: Specification perturbation moves both layers coherently. Cases 3 and 4 perturb the specifications rather than the topology. Loosening φA _A (unlimited destroys, Case 3) shrinks the winning region from 23,730 to 20,526 and drops DDR from 53.9% to 47.5%—both layers agree that removing the attacker’s resource constraint makes the topology more dangerous. Loosening φD _D (active ≥2≥ 2, Case 4) expands the winning region to 33,966 and lifts DDR to 77.9%—both layers agree that a more permissive safety objective makes defense easier. The coherence is structural. Specifications govern the geometry of the game (which states are safe, how large the arena is); the MARL behavior responds to that geometry. The two layers are analytically distinct but coupled through the specifications. Finding 3: The fingerprint is an actionable diagnostic. A security architect comparing Case 1 to Case 5 sees: removing the VPN bypass barely changes the formal safety margin (|||W|: 23,730 → 23,858) but transforms the operational reality (DDR: 53.9% → 80.7%). The recommendation is concrete: close the VPN bypass. The formal game guarantees safety is preserved; the MARL layer quantifies the operational improvement. Neither static analysis nor informal simulation jointly produces this formal-plus-operational assessment. 8 Related Work Shielded Reinforcement Learning. The foundational ShRL pipeline—LTL specification → DFA → product MDP → shield—was established by Bloem et al. [2] and Alshiekh et al. [1], with extensions to k-stabilizing shields [3] and probabilistic settings [5, 6], and a recent CACM survey [4]. These works model the interaction as agent versus adversarial environment (nature): the environment is not a strategic player with its own specification but a worst-case abstraction of stochastic dynamics, and the synthesis target is a runtime filter for the agent. Multi-agent shielding [15, 16] shields cooperative agents under a shared specification. POMDP-shielding extensions [7, 8] address partial observability under explicit abstraction assumptions. Across this literature, the winning region appears as an intermediate computation; the shield is the deliverable. The framework presented here inverts the role: the verdict is the deliverable, the shield is its witness, and two adversarial agents—each with their own automaton—enforce different stages of the safety game’s solution. Reactive Synthesis with Environment Assumptions. Reactive synthesis distinguishes assumptions from guarantees and wires the distinction into the synthesis objective: env satisfies A → sys satisfies G [17, 18]. The two specifications collapse into a single synthesis target. The architecture used here keeps both specifications first-class: φD _D enters the safety game as the seed of the unsafe set, φA _A enters as a successor filter during attractor computation. The two enter different stages of the fixed-point iteration, and the resulting winning region depends on both. Network Security Metrics. Attack-graph methods quantify vulnerability composition, probabilistic compromise likelihood, and hardening options over graph-based attack models, including cyclic AND/OR and Bayesian variants [22, 23, 24, 25, 26]. They do not compute temporal-logic winning regions, attractor shells, or shield-induced action restrictions. The metrics presented in Section 5 operate on dynamic safety-game attractor decompositions under worst-case adversarial interaction with formal temporal-logic specifications. The distinction is structural: attack-graph metrics measure static vulnerability composition; the metrics here measure dynamic defensibility under strategic interaction. Shield Friction has no direct analogue in either community; it bridges them by quantifying the operational cost of formal safety. Game-Theoretic Security. Stackelberg security games [31], adversarial patrolling [27], and dynamic resource allocation [28] model strategic attacker-defender interaction using optimization-theoretic formulations: equilibrium computation under utility specifications, not winning-region computation under temporal-logic specifications. The two communities address overlapping problems with disjoint mathematical machinery; the framework presented here lives in the automata-theoretic register and does not displace optimization-theoretic methods. RL for Cybersecurity. The CybORG/CAGE Challenge [19, 20, 21] has run multiple iterations with extensive MARL submissions for autonomous network defense. Safety in this line of work is enforced through soft methods: reward shaping, constrained optimization, Lagrangian penalties. Existing CAGE-style evaluations report empirical agent performance against a fixed adversary distribution; they do not produce topology-level temporal-logic defensibility certificates or shield-derived winning-region diagnostics. Empirical success against any particular adversary distribution cannot prove the absence of a winning attacker strategy—only a formal verdict can. The framework here is complementary: it provides the formal defensibility layer the empirical work assumes but does not test, on the small tractable subsystems where the formal layer can be computed. 9 Discussion The analytical paradigm. Standard ShRL presents shield synthesis as the means of producing runtime-safe RL agents. The same machinery is more productively used differently. The pipeline—specification compilation, product game construction, attractor computation, winning region extraction—is an analytical instrument; its outputs are structural insights about the system, not runtime filters for an online agent. The what-if analysis is the demonstration. The most actionable finding—that removing a single VPN bypass edge transforms the defender dominance ratio from 53.9% to 80.7% without meaningfully changing the winning region—is a design-time insight directed at a security architect, not a runtime signal for a deployed agent. The defensibility fingerprints, the shell decompositions, and the metrics comparison are diagnostic artifacts intended for offline analysis. They answer “how should we configure this network?” not “which action should the agent take now?” The reframing is independent of whether the scalability limitations of explicit-state shield synthesis are eventually overcome. Scalable synthesis through state abstraction, symbolic methods, or compositional decomposition would extend the analytical paradigm to larger topologies. A permanent scalability wall would leave the paradigm valid for tractable subsystems, where formal analysis informs architectural decisions for the larger network the segment represents. The paradigm survives either outcome. A label for the mode. It is convenient to refer to the mode of analysis demonstrated here as shielded analysis: shield synthesis used as an instrument for offline structural inference rather than online runtime enforcement. Its inputs are specifications and system models; its outputs are verdicts, winning regions, and structural metrics. Its tractability bound matches the use case scope rather than blocking deployment; its sensitivity questions concern specification perturbation and model fidelity rather than runtime drift; its products inform architectural decisions rather than agent action selection. Probabilistic, partially observable, compositional, and neuro-symbolic shield extensions—currently positioned as runtime safety mechanisms—admit equally direct readings as analytical instruments. The framework presented here is one instantiation of the mode; the reading generalizes. Scope of the guarantee. The defensibility verdict is exact within the assumed model. Like all formal verification results, it is conditioned on the model’s fidelity to the real system. Unlike runtime enforcement, this conditioning is part of the contract: the architect supplies the model, reads the verdict, and uses the verdict to inform—not to dictate—the architectural decision. The verdict does not transfer directly to environments where the transition model is unknown, stochastic, or partially observable; what transfers is the structural register: which specifications interact dangerously, which topological features dominate operational outcomes, which architectural changes improve margins, which configurations admit no defense at all. The model is small. The insights are not. For the regime this paper targets, the framework is tractable on commodity consumer hardware: the full pipeline—attractor solution, successor-graph construction, and ten-seed MARL training across all five what-if cases—completes in under one hour (Section 7). Limitations. Scalability: the product state space grows as |ℋ||V||H|^|V|, confining explicit-state computation to small segments (approximately |V|≤7|V|≤ 7). This is a fundamental property of explicit-state safety games, not specific to the formulation here. Deterministic transitions: the safety game assumes deterministic transitions. Real networks involve stochastic elements (intermittent failures, probabilistic detection); extending to probabilistic safety games [5, 6] is a natural direction. Simplified host model: five statuses abstract away significant real-world complexity, including partial compromise stages, lateral movement techniques, and graded detection confidence. MARL convergence and hyperparameter sensitivity: formal Nash convergence under shield-restricted action sets and persistent exploration is not proven; the empirical signal across 10 seeds is consistent with stable post-convergence behavior, as detailed in Section 6. The narrow inter-seed confidence intervals demonstrate training reproducibility under fixed hyperparameters but do not characterize sensitivity to the learning rate, discount factor, or exploration schedule; whether per-case DDR ranks are stable across (α,γ,ε)(α,γ, ) regimes is an open empirical question. Single-topology evaluation: the empirical study spans five perturbations of one 5-host topology family. The what-if analysis demonstrates the framework’s comparative diagnostic power within this family; evaluation across structurally distinct topology families is required to characterize the framework’s behavior in regimes not sampled here, and is a natural direction for follow-up work. Verdict robustness under model perturbation: the defensibility verdict is exact within the assumed model. Empirical robustness of the verdict and the structural register under transition-function perturbations (e.g., probabilistic Spread, noisy detection) is not characterized here. The design-time framing makes verdict-stability under model perturbation the right axis to interrogate, and we leave this to future work. 10 Conclusion We have presented a framework that repositions shield synthesis from a runtime enforcement mechanism to a design-time analytical instrument for network defensibility assessment. The dual-specification constrained safety game, with φD _D seeding the unsafe set and φA _A filtering the attacker’s successors, is the architectural feature that makes the framework’s outputs first-class. The defensibility verdict, elevated from intermediate computation to primary deliverable, provides a formal certificate that no informal method produces: proof that a topology-specification pair is or is not defensible. The six topology defensibility metrics and the defensibility fingerprint translate the mathematical structure of the attractor decomposition and the post-convergence MARL behavior into a unified diagnostic. The what-if analysis demonstrates their value: a security architect can compare network configurations and identify that a single forgotten VPN rule—barely visible to the formal safety metrics—transforms the operational balance from a contested 54% to a comfortable 81% defender dominance. The most important structural finding is the decoupling between the two layers. The formal safety game and the MARL behavior measure fundamentally different properties: one asks whether survival is possible, the other asks how well survival can be achieved. A topology may be formally defensible yet operationally overwhelmed, or nearly identical in formal structure yet radically different in operational outcome. Neither layer alone captures the full picture. The two-layer architecture is necessary, not redundant. Future work extends naturally. Probabilistic shield synthesis addresses the deterministic-transition restriction. State abstraction and compositional specification decomposition push back the scalability wall. Automated topology extraction from network scanning tools suggests a path toward closing the loop between architectural artifacts and their formal analysis. Each direction inherits the same paradigm. The defensibility verdict is the output, not the safe policy. References Alshiekh et al. [2018] M. Alshiekh, R. Bloem, R. Ehlers, B. Könighofer, S. Niekum, and U. Topcu. Safe reinforcement learning via shielding. In Proc. AAAI, p. 2669–2678, 2018. doi:10.1609/aaai.v32i1.11797. Bloem et al. [2015] R. Bloem, B. Könighofer, R. Könighofer, and C. Wang. Shield synthesis: Runtime enforcement for reactive systems. In Proc. TACAS, LNCS vol. 9035, Springer, p. 533–548, 2015. doi:10.1007/978-3-662-46681-0_51. Könighofer et al. [2017] B. Könighofer, M. Alshiekh, R. Bloem, L. R. Humphrey, R. Könighofer, U. Topcu, and C. Wang. Shield synthesis. Formal Methods in System Design, 51(2):332–361, 2017. doi:10.1007/s10703-017-0276-9. Könighofer et al. [2025] B. Könighofer, R. Bloem, N. Jansen, S. Junges, and S. Pranger. Shields for safe reinforcement learning. Communications of the ACM, 68(11):80–90, 2025. doi:10.1145/3715958. Jansen et al. [2020] N. Jansen, B. Könighofer, S. Junges, A. Serban, and R. Bloem. Safe reinforcement learning using probabilistic shields. In Proc. CONCUR, LIPIcs vol. 171, Schloss Dagstuhl–Leibniz-Zentrum für Informatik, article 3, p. 3:1–3:16, 2020. doi:10.4230/LIPIcs.CONCUR.2020.3. Hamel-De le Court et al. [2025] E. Hamel-De le Court, F. Belardinelli, and A. W. Goodall. Probabilistic shielding for safe reinforcement learning. In Proc. AAAI, 39(15):16091–16099, 2025. doi:10.1609/aaai.v39i15.33767. Carr et al. [2023] S. Carr, N. Jansen, S. Junges, and U. Topcu. Safe reinforcement learning via shielding under partial observability. In Proc. AAAI, p. 14748–14756, 2023. doi:10.1609/aaai.v37i12.26723. Melcer et al. [2024] D. Melcer, C. Amato, and S. Tripakis. Shield decomposition for safe reinforcement learning in general partially observable multi-agent environments. Reinforcement Learning Journal, 4:1965–1994, 2024. Tappler et al. [2022] M. Tappler, S. Pranger, B. Könighofer, E. Muškardin, R. Bloem, and K. G. Larsen. Automata learning meets shielding. In Proc. ISoLA, LNCS vol. 13701, Springer, p. 335–359, 2022. doi:10.1007/978-3-031-19849-6_20. Brunke et al. [2022] L. Brunke, M. Greeff, A. W. Hall, Z. Yuan, S. Zhou, J. Panerati, and A. P. Schoellig. Safe learning in robotics: From learning-based control to safe reinforcement learning. Annual Review of Control, Robotics, and Autonomous Systems, 5:411–444, 2022. Grädel et al. [2002] E. Grädel, W. Thomas, and T. Wilke, editors. Automata, Logics, and Infinite Games: A Guide to Current Research. LNCS vol. 2500, Springer, 2002. doi:10.1007/3-540-36387-4. Baier and Katoen [2008] C. Baier and J.-P. Katoen. Principles of Model Checking. MIT Press, 2008. Littman [1994] M. L. Littman. Markov games as a framework for multi-agent reinforcement learning. In Proc. ICML, p. 157–163, Morgan Kaufmann, 1994. Littman and Szepesvári [1996] M. L. Littman and C. Szepesvári. A generalized reinforcement-learning model: Convergence and applications. In Proc. ICML, p. 310–318, 1996. ElSayed-Aly et al. [2021] I. ElSayed-Aly, S. Bharadwaj, C. Amato, R. Ehlers, U. Topcu, and L. Feng. Safe multi-agent reinforcement learning via shielding. In Proc. AAMAS, IFAAMAS, p. 483–491, 2021. Xiao et al. [2023] W. Xiao, Y. Lyu, and J. M. Dolan. Model-based dynamic shielding for safe and efficient multi-agent reinforcement learning. arXiv:2304.06281, 2023. Chatterjee et al. [2008] K. Chatterjee, T. A. Henzinger, and B. Jobstmann. Environment assumptions for synthesis. In Proc. CONCUR, LNCS vol. 5201, Springer, p. 147–161, 2008. doi:10.1007/978-3-540-85361-9_14. Piterman et al. [2006] N. Piterman, A. Pnueli, and Y. Sa’ar. Synthesis of Reactive(1) designs. In Proc. VMCAI, LNCS vol. 3855, Springer, p. 364–380, 2006. doi:10.1007/11609773_24. CAGE Challenge [2023] CAGE Challenge. CybORG: Cyber Operations Research Gym. GitHub repository, https://github.com/cage-challenge/CybORG, 2023. Standen et al. [2021] M. Standen, M. Lucas, D. Bowman, T. J. Richer, J. Kim, and D. Marriott. CybORG: A gym for the development of autonomous cyber agents. arXiv:2108.09118, 2021. Kiely et al. [2025] M. Kiely, M. Ahiskali, E. Borde, B. Bowman, D. Bowman, D. Van Bruggen, K. C. Cowan, P. Dasgupta, E. Devendorf, B. Edwards, A. Fitts, S. Fugate, R. Gabrys, W. Gould, H. H. Huang, J. Jacobs, R. Kerr, I. J. King, L. Li, L. Martinez, C. Moir, C. Murphy, O. Naish, C. Owens, M. Purchase, A. Ridley, A. Taylor, S. Farmer, W. J. Valentine, and Y. Zhang. CAGE challenge 4: A scalable multi-agent reinforcement learning gym for autonomous cyber defence. AI Magazine, 46(2), 2025. doi:10.1002/aaai.70021. Manadhata and Wing [2004] P. K. Manadhata and J. M. Wing. Measuring a system’s attack surface. Technical Report CMU-CS-04-102, School of Computer Science, Carnegie Mellon University, 2004. Wang et al. [2007] L. Wang, A. Singhal, and S. Jajodia. Measuring the overall security of network configurations using attack graphs. In Proc. DBSec, LNCS vol. 4602, Springer, p. 98–112, 2007. doi:10.1007/978-3-540-73538-0_9. Pamula et al. [2006] J. Pamula, S. Jajodia, P. Ammann, and V. Swarup. A weakest-adversary security metric for network configuration security analysis. In Proc. QoP, ACM, p. 31–38, 2006. doi:10.1145/1179494.1179502. Zenitani [2023] K. Zenitani. Attack graph analysis: An explanatory guide. Computers & Security, 126:103081, 2023. doi:10.1016/j.cose.2022.103081. Wang et al. [2008] L. Wang, T. Islam, T. Long, A. Singhal, and S. Jajodia. An attack graph-based probabilistic security metric. In Data and Applications Security XXII, LNCS vol. 5094, Springer, p. 283–296, 2008. doi:10.1007/978-3-540-70567-3_22. Klaška et al. [2021] D. Klaška, A. Kučera, V. Musil, and V. Řehák. Regstar: Efficient strategy synthesis for adversarial patrolling games. In Proc. UAI, PMLR vol. 161, p. 471–481, 2021. Shishika et al. [2023] D. Shishika, Y. Guan, J. R. Marden, M. Dorothy, P. Tsiotras, and V. Kumar. Dynamic adversarial resource allocation: The dDAB game. arXiv:2304.02172, 2023. Batfish [2023] The Batfish Open Source Project. Batfish: An open source network configuration analysis tool. https://w.batfish.org, 2023. Kazemian et al. [2012] P. Kazemian, G. Varghese, and N. McKeown. Header space analysis: Static checking for networks. In Proc. NSDI, p. 113–126, USENIX Association, 2012. Kiekintveld et al. [2009] C. Kiekintveld, M. Jain, J. Tsai, J. Pita, F. Ordóñez, and M. Tambe. Computing optimal randomized resource allocations for massive security games. In Proc. AAMAS, IFAAMAS, p. 689–696, 2009. Appendix A Empirical Correlation Structure of the Defensibility Metrics Section 5 introduces six conceptually distinct metrics. The empirical relationships among them, evaluated across the five what-if cases of Section 7, are reported here. We compute pairwise Pearson correlations directly from the values in Table 6, with all metrics taken in their raw orientations (ATK, SNK, FRC, STP danger-oriented; MSV, DDR safety-oriented). Table 7: Pairwise Pearson correlations across the five what-if cases. Diagonal entries are unity. ATK SNK FRC STP MSV DDR ATK 1.001.00 +0.99+0.99 +0.99+0.99 −0.86-0.86 +0.86+0.86 −0.54-0.54 SNK 1.001.00 +1.00+1.00 −0.78-0.78 +0.78+0.78 −0.54-0.54 FRC 1.001.00 −0.76-0.76 +0.76+0.76 −0.54-0.54 STP 1.001.00 −1.00-1.00 +0.49+0.49 MSV 1.001.00 −0.49-0.49 DDR 1.001.00 Three observations follow. A compromise-pressure axis (ATK, SNK, FRC). The boundary, interior, and action-space metrics exhibit pairwise correlations of 0.9850.985 or higher across the five cases. They are conceptually distinct—ATK measures attack-edge-weighted exposure on the boundary between W and Attr∗Attr^*, SNK measures absorbed mass within Attr∗Attr^*, and FRC measures the action-space restriction induced by the shield in W—but in the regime sampled by perturbations of one 5-host topology family, they comove. We read them, in this regime, as projections of one underlying compromise-pressure axis. Their conceptual distinctness predicts decoupling under perturbations targeting the boundary, the interior, or the legal-move structure asymmetrically; the present study does not exhibit such a regime. Structural anti-correlation between STP and MSV. The Shannon entropy of the shell distribution (STP) and the mean shell depth (MSV) reach r=−1.000r=-1.000 across the five cases. Both are summary statistics of the same small-support shell distribution—typically kmax∈3,4k_ ∈\3,4\ in the regime studied here—and the perturbations sampled in this study traverse a one-dimensional subset of the joint (entropy,mean)(entropy,mean) surface along which the two functionals move in opposite directions. The two metrics are best read, in this regime, as orientation flips on a single depth-distribution axis. Decoupling would require a regime with substantially deeper attractors and a richer family of shell distributions. Operational orthogonality of DDR. The Defender Dominance Ratio is structurally orthogonal to all five formal metrics (|r|≤0.54|r|≤ 0.54). DDR is not predictable from the formal layer in the regime sampled here: no formal metric, taken alone, determines the operational outcome at L200 across the five cases. This orthogonality is the empirical face of the two-layer decoupling that motivates the framework: the safety game and the post-convergence MARL layer measure fundamentally different aspects of defensibility, and the Case 2-vs-Case 5 contrast (Table 6) is a single dramatic illustration of a structural property of the metric space. Statistical scope. With n=5n=5, the correlations reported here are descriptive observations about how the five chosen perturbations sample the metric space rather than inferential claims about a population of topologies. The magnitudes (|r|≥0.985|r|≥ 0.985 for the compromise-pressure triplet, |r|=1.000|r|=1.000 for the STP–MSV pair) are large enough to render the structural reading visible without requiring statistical inference. We expect the qualitative pattern—collapse of formal metrics into a smaller set of effective axes, with DDR orthogonal to all of them—to recur across topology families, but the precise correlations are regime-dependent.

Instant research discovery