tz98lab/dlr-ne-ics-securityForschungscode zur Implementierung der Berechnung des dynamischen Niedrigrang-Nash-Gleichgewichts für stochastische ICS-Sicherheitsspiele zwischen fortgeschrittenen persistenten Bedrohungen und Moving-Target-Verteidigungen.
Dynamische Niedrigrang-Gleichgewichtsberechnung für stochastische Spiele zwischen Advanced Persistent Threats und Moving Target Defense
Regular Paper, zur Begutachtung bei Automatica (erneut eingereicht im Oktober 2026)
Dieses Repository enthält die Implementierung und experimentelle Validierung des Dynamical Low-Rank Nash Equilibrium (DLR-NE)-Algorithmus zur Berechnung von Nash-Gleichgewichten in hochdimensionalen Sicherheitsspielen industrieller Steuerungssysteme (ICS).
Die strategische Interaktion zwischen Advanced Persistent Threats (APTs) und Moving Target Defenses (MTDs) wird als stochastisches Nullsummenspiel mit zwei Spielern über einen kontinuierlichen Zustandsraum der Dimension $n \sim 10^3$–$10^4$ modelliert. Die zentrale Erkenntnis ist, dass die physikalische Niedrigrang-Kopplung von Angriffs- und Verteidigungskanälen (eine strukturelle Eigenschaft, die der ICS-Netzwerktopologie inhärent ist) eine traktierbare Niedrigrang-Neuronale-Netz-Approximation der Gleichgewichtswertfunktion ermöglicht, wodurch die Komplexität pro Iteration von $\mathcal{O}(n^2)$ auf $\mathcal{O}(nr^2)$ reduziert wird – eine Beschleunigung um $\Theta(n/r^2)$.
| Theorem | Aussage | Experiment |
|---|---|---|
| Theorem 1 | Globale Niedrigrang-Approximationsfehlerschranke für die optimale Wertfunktion $V^*$ | Exp. 1 |
| Theorem 2 | Geometrische Konvergenz von DLR-NE mit expliziter Zerlegung des stationären Fehlers | Exp. 2 |
| Theorem 3 | Komplexität pro Iteration $\mathcal{O}(nr^2)$ und Beschleunigung $\Theta(n/r^2)$ gegenüber Vollrang-Baselines | Exp. 3 |
| Korollar 1 | Spieltheoretische Robustheit: Die Gleichgewichtssensitivität wird durch die Konditionszahl $\kappa(S)$ kontrolliert | Exp. 4 |
dlr-ne-ics-security/
├── src/ # Core algorithmic modules
│ ├── environment.py # Synthetic nonlinear power-system dynamics
│ ├── networks.py # Low-rank and full-rank neural networks
│ ├── bellman.py # Bellman operator and greedy Nash policy extractor
│ ├── dlra_vi.py # Algorithm 1: DLR-NE
│ └── utils.py # FLOPs accounting, EYM error, metrics
│
├── experiments/ # Experimental scripts (one per theorem)
│ ├── exp01_truncation_error.py # Theorem 1: Low-rank truncation error
│ ├── exp02_convergence.py # Theorem 2: Convergence of DLR-NE
│ ├── exp03_complexity.py # Theorem 3: Computational complexity
│ ├── exp04_robustness.py # Corollary 1: Game-theoretic robustness
│ ├── exp05_tradeoff.py # Compression-accuracy Pareto frontier
│ └── exp06_ablation.py # Ablation: necessity of basis augmentation
│
├── data/ # Generated datasets (excluded from git)
├── results/ # Figures and logs (excluded from git)
├── notebooks/ # Prototyping and visualization
├── requirements.txt # Python dependencies
└── README.md # This file
# Clone the repository
git clone https://github.com/tz98lab/dlr-ne-ics-security.git
cd dlr-ne-ics-security
# Create a virtual environment (recommended)
python -m venv venv
source venv/bin/activate # Linux/Mac
# venv\Scripts\activate # Windows
# Install dependencies
pip install -r requirements.txt
numpy>=1.24.0
scipy>=1.10.0
matplotlib>=3.7.0
torch>=2.0.0
Alle Experimente sind eigenständig und können unabhängig voneinander ausgeführt werden. Jedes Skript erzeugt Abbildungen im Verzeichnis results/figures/.
Hinweis zum Maßstab: Die Standardkonfigurationen verwenden $n=200$ für eine schnelle Demonstration. Um die im Paper berichteten Ergebnisse im vollen Maßstab ($n \sim 10^3$) zu reproduzieren, ändern Sie die
PowerSystemConfigam Anfang jedes Skripts (siehe Inline-Kommentare).
Validiert, dass der Abschneidefehler $|V_{\mathrm{full}} - \widehat{V}r|\infty$ mit dem Rang $r$ abnimmt und mit der theoretischen Vorhersage von Eckart-Young-Mirsky übereinstimmt.
python experiments/exp01_truncation_error.py
Ausgabe: results/figures/exp1_truncation_error.png
Erwartet: Der gemessene Fehler (blaue Kreise) folgt der theoretischen Schranke $L_\phi |w_{\mathrm{out}}^*|2 R{\mathcal{X}} \epsilon_{\mathrm{EYM}}(r)$ (lila gestrichelte Linie); das Spektrum der Singulärwerte zeigt einen schnellen Abfall.
Validiert die geometrische Konvergenz mit Rate $\gamma$ und die explizite stationäre Fehlerumgebung $\varepsilon_{\mathrm{total}}/(1-\gamma)$.
python experiments/exp02_convergence.py
Ausgabe: results/figures/exp2_convergence.png
Erwartet: Die Fehlerkurven fallen zunächst entlang der $\gamma^k$-Einhüllenden ab und gehen dann in ein Plateau über, das durch das Inner-Loop-Budget $s^$ dominiert wird (eine Halbierung von $s^$ kostet einen Faktor von $\approx 20$ an Genauigkeit); die Batch-Größe $N_b$ hat einen vergleichsweise vernachlässigbaren Effekt.
Validiert die Komplexität pro Iteration von $\mathcal{O}(nr^2)$ und die Beschleunigung um $\Theta(n/r^2)$ gegenüber Vollrang-FC-NN-Baselines.
python experiments/exp03_complexity.py
Ausgabe: results/figures/exp3_complexity.png
Erwartet: DLR-NE skaliert linear in $n$ (Steigung 1 in log-log), FC-NN skaliert quadratisch (Steigung 2); gemessene FLOPs-Beschleunigung $\approx 12\times$ (Wall-Clock $\approx 4\times$) bei $n=2000, r=10$.
Validiert die lineare Beziehung $|V(\cdot;\pi_D,\pi_A) - V(\cdot;\tilde{\pi}D,\pi_A)|\infty \le L_\kappa |\Delta S|F$ mit einer endlichen, $\beta$-tunbaren Sensitivitätskonstante $L\kappa$, die durch die Konditionszahl $\kappa(S)$ zertifiziert wird (ein A-priori-Worst-Case-Zertifikat).
python experiments/exp04_robustness.py
Ausgabe: results/figures/exp4_robustness.png
Erwartet: Die Wertabweichung ist linear in $|\Delta S|_F$ mit einer Steigung, die mit dem spektralen Regularisierungsgewicht $\beta$ abnimmt; $\kappa(S)$ wird durch Erhöhung von $\beta$ komprimiert.
Erkundet die Pareto-Front zwischen Kompressionsrate und Nutzen der Gleichgewichtspolitik.
python experiments/exp05_tradeoff.py
Ausgabe: results/figures/exp5_tradeoff.png
Erwartet: Optimaler Punkt bei $r = 5$: $\approx 94%$ Parameterkompression bei $\approx 2.3%$ Nutzenverlust.
Vergleicht drei Varianten: (i) vollständiger Algorithmus 1, (ii) feste Basis, (iii) keine Retraktion.
python experiments/exp06_ablation.py
Ausgabe: results/figures/exp6_ablation.png
Erwartet: Die Variante mit fester Basis stagniert; die Variante ohne Retraktion ist instabil; der vollständige Algorithmus 1 erreicht einen stabilen Abfall bei kontrollierten Kosten.