tz98lab/dlr-ne-ics-securityCode de recherche implémentant le calcul de l'équilibre de Nash dynamique à rang faible pour les jeux de sécurité ICS stochastiques entre menaces persistantes avancées et défenses à cible mobile.
Calcul d'équilibre dynamique de rang faible pour les jeux stochastiques entre menaces persistantes avancées et défense par cible mobile
Article régulier, en cours d'évaluation à Automatica (resoumis en octobre 2026)
Ce dépôt contient l'implémentation et la validation expérimentale de l'algorithme Dynamical Low-Rank Nash Equilibrium (DLR-NE) pour le calcul des équilibres de Nash dans les jeux de sécurité des systèmes de contrôle industriels (ICS) de grande dimension.
L'interaction stratégique entre les menaces persistantes avancées (APT) et les défenses par cible mobile (MTD) est modélisée comme un jeu stochastique à somme nulle à deux joueurs sur un espace d'états continu de dimension $n \sim 10^3$–$10^4$. L'idée clé est que le couplage physique de rang faible des canaux d'attaque et de défense (une propriété structurelle inhérente à la topologie des réseaux ICS) permet une approximation tractable par réseau de neurones de rang faible de la fonction de valeur d'équilibre, réduisant la complexité par itération de $\mathcal{O}(n^2)$ à $\mathcal{O}(nr^2)$, soit une accélération de $\Theta(n/r^2)$.
| Théorème | Énoncé | Expérience |
|---|---|---|
| Théorème 1 | Borne globale d'erreur d'approximation de rang faible pour la fonction de valeur optimale $V^*$ | Exp. 1 |
| Théorème 2 | Convergence géométrique de DLR-NE avec décomposition explicite de l'erreur en régime permanent | Exp. 2 |
| Théorème 3 | Complexité par itération $\mathcal{O}(nr^2)$ et accélération $\Theta(n/r^2)$ par rapport aux références de rang plein | Exp. 3 |
| Corollaire 1 | Robustesse théorique des jeux : la sensibilité de l'équilibre est contrôlée par le nombre de conditionnement $\kappa(S)$ | 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
Toutes les expériences sont autonomes et peuvent être exécutées indépendamment. Chaque script génère des figures dans le répertoire results/figures/.
Note sur l'échelle : Les configurations par défaut utilisent $n=200$ pour une démonstration rapide. Pour reproduire les résultats à pleine échelle rapportés dans l'article ($n \sim 10^3$), modifiez le
PowerSystemConfigen haut de chaque script (voir les commentaires en ligne).
Valide que l'erreur de troncature $|V_{\mathrm{full}} - \widehat{V}r|\infty$ décroît avec le rang $r$ et correspond à la prédiction théorique d'Eckart-Young-Mirsky.
python experiments/exp01_truncation_error.py
Sortie : results/figures/exp1_truncation_error.png
Attendu : L'erreur mesurée (cercles bleus) suit la borne théorique $L_\phi |w_{\mathrm{out}}^*|2 R{\mathcal{X}} \epsilon_{\mathrm{EYM}}(r)$ (ligne pointillée violette) ; le spectre des valeurs singulières montre une décroissance rapide.
Valide la convergence géométrique avec un taux $\gamma$ et le voisinage d'erreur explicite en régime permanent $\varepsilon_{\mathrm{total}}/(1-\gamma)$.
python experiments/exp02_convergence.py
Sortie : results/figures/exp2_convergence.png
Attendu : Les courbes d'erreur décroissent d'abord le long de l'enveloppe $\gamma^k$, puis s'aplatissent en un plateau dominé par le budget de la boucle interne $s^$ (diviser $s^$ par deux coûte un facteur d'environ $20$ en précision) ; la taille du lot $N_b$ a un effet comparativement négligeable.
Valide la complexité par itération $\mathcal{O}(nr^2)$ et l'accélération $\Theta(n/r^2)$ par rapport aux références FC-NN de rang plein.
python experiments/exp03_complexity.py
Sortie : results/figures/exp3_complexity.png
Attendu : DLR-NE évolue linéairement en $n$ (pente 1 en log-log), FC-NN évolue quadratiquement (pente 2) ; accélération mesurée en FLOPs $\approx 12\times$ (temps réel $\approx 4\times$) à $n=2000, r=10$.
Valide la relation linéaire $|V(\cdot;\pi_D,\pi_A) - V(\cdot;\tilde{\pi}D,\pi_A)|\infty \le L_\kappa |\Delta S|F$ avec une constante de sensibilité finie et ajustable par $\beta$, $L\kappa$, certifiée par le nombre de conditionnement $\kappa(S)$ (un certificat a priori du pire cas).
python experiments/exp04_robustness.py
Sortie : results/figures/exp4_robustness.png
Attendu : La déviation de valeur est linéaire en $|\Delta S|_F$ avec une pente décroissante en fonction du poids de régularisation spectrale $\beta$ ; $\kappa(S)$ est réduit en augmentant $\beta$.
Explore la frontière de Pareto entre le taux de compression et l'utilité de la politique d'équilibre.
python experiments/exp05_tradeoff.py
Sortie : results/figures/exp5_tradeoff.png
Attendu : Point optimal à $r = 5$ : $\approx 94%$ de compression des paramètres pour $\approx 2.3%$ de perte d'utilité.
Compare trois variantes : (i) l'algorithme 1 complet, (ii) base fixe, (iii) sans rétraction.
python experiments/exp06_ablation.py
Sortie : results/figures/exp6_ablation.png
Attendu : La variante à base fixe stagne ; la variante sans rétraction est instable ; l'algorithme 1 complet atteint une décroissance stable à coût contrôlé.