tz98lab/dlr-ne-ics-securityCodice di ricerca che implementa il calcolo dell'Equilibrio di Nash a Basso Rango Dinamico per giochi di sicurezza ICS stocastici tra minacce persistenti avanzate e difese a bersaglio mobile.
Calcolo dell'Equilibrio a Basso Rango Dinamico per Giochi Stocastici tra Minacce Persistenti Avanzate e Difesa a Bersaglio Mobile
Articolo Regolare, in revisione presso Automatica (re-inviato a ottobre 2026)
Questo repository contiene l'implementazione e la validazione sperimentale dell'algoritmo Dynamical Low-Rank Nash Equilibrium (DLR-NE) per il calcolo degli equilibri di Nash in giochi di sicurezza per Sistemi di Controllo Industriale (ICS) ad alta dimensionalità.
L'interazione strategica tra Minacce Persistenti Avanzate (APT) e Difese a Bersaglio Mobile (MTD) è modellata come un gioco stocastico a somma zero a due giocatori su uno spazio di stato continuo di dimensione $n \sim 10^3$–$10^4$. L'intuizione chiave è che l'accoppiamento fisico a basso rango dei canali di attacco e difesa (una proprietà strutturale inerente alla topologia di rete ICS) consente un'approssimazione trattabile a basso rango tramite rete neurale della funzione di valore di equilibrio, riducendo la complessità per iterazione da $\mathcal{O}(n^2)$ a $\mathcal{O}(nr^2)$, un'accelerazione di $\Theta(n/r^2)$.
| Teorema | Enunciato | Esperimento |
|---|---|---|
| Teorema 1 | Limite globale dell'errore di approssimazione a basso rango per la funzione di valore ottimale $V^*$ | Esp. 1 |
| Teorema 2 | Convergenza geometrica di DLR-NE con decomposizione esplicita dell'errore a regime | Esp. 2 |
| Teorema 3 | Complessità per iterazione $\mathcal{O}(nr^2)$ e accelerazione $\Theta(n/r^2)$ rispetto ai baseline a rango pieno | Esp. 3 |
| Corollario 1 | Robustezza game-teorica: la sensibilità dell'equilibrio è controllata dal numero di condizionamento $\kappa(S)$ | Esp. 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
Tutti gli esperimenti sono autocontenuti e possono essere eseguiti in modo indipendente. Ogni script genera figure nella directory results/figures/.
Nota sulla Scala: Le configurazioni predefinite utilizzano $n=200$ per una rapida dimostrazione. Per riprodurre i risultati su scala completa riportati nell'articolo ($n \sim 10^3$), modificare
PowerSystemConfigall'inizio di ciascuno script (vedere i commenti inline).
Convalida che l'errore di troncamento $|V_{\mathrm{full}} - \widehat{V}r|\infty$ decresce con il rango $r$ e si allinea con la previsione teorica di Eckart-Young-Mirsky.
python experiments/exp01_truncation_error.py
Output: results/figures/exp1_truncation_error.png
Atteso: L'errore misurato (cerchi blu) segue il limite teorico $L_\phi |w_{\mathrm{out}}^*|2 R{\mathcal{X}} \epsilon_{\mathrm{EYM}}(r)$ (linea tratteggiata viola); lo spettro dei valori singolari mostra un rapido decadimento.
Convalida la convergenza geometrica con tasso $\gamma$ e l'intorno esplicito dell'errore a regime $\varepsilon_{\mathrm{total}}/(1-\gamma)$.
python experiments/exp02_convergence.py
Output: results/figures/exp2_convergence.png
Atteso: Le curve di errore dapprima decadono lungo l'inviluppo $\gamma^k$, poi si appiattiscono in un plateau dominato dal budget del ciclo interno $s^$ (dimezzare $s^$ costa un fattore di $\approx 20$ in accuratezza); la dimensione del batch $N_b$ ha un effetto comparativamente trascurabile.
Convalida la complessità per iterazione $\mathcal{O}(nr^2)$ e l'accelerazione $\Theta(n/r^2)$ rispetto ai baseline FC-NN a rango pieno.
python experiments/exp03_complexity.py
Output: results/figures/exp3_complexity.png
Atteso: DLR-NE scala linearmente in $n$ (pendenza 1 in scala log-log), FC-NN scala quadraticamente (pendenza 2); accelerazione misurata in FLOPs $\approx 12\times$ (tempo reale $\approx 4\times$) a $n=2000, r=10$.
Convalida la relazione lineare $|V(\cdot;\pi_D,\pi_A) - V(\cdot;\tilde{\pi}D,\pi_A)|\infty \le L_\kappa |\Delta S|F$ con una costante di sensibilità finita e regolabile tramite $\beta$, $L\kappa$, certificata dal numero di condizionamento $\kappa(S)$ (un certificato a priori del caso peggiore).
python experiments/exp04_robustness.py
Output: results/figures/exp4_robustness.png
Atteso: La deviazione del valore è lineare in $|\Delta S|_F$ con pendenza decrescente rispetto al peso di regolarizzazione spettrale $\beta$; $\kappa(S)$ viene compresso aumentando $\beta$.
Esplora la frontiera di Pareto tra rapporto di compressione e utilità della politica di equilibrio.
python experiments/exp05_tradeoff.py
Output: results/figures/exp5_tradeoff.png
Atteso: Punto ottimale a $r = 5$: $\approx 94%$ di compressione dei parametri con $\approx 2.3%$ di perdita di utilità.
Confronta tre varianti: (i) Algoritmo 1 completo, (ii) base fissa, (iii) senza retrazione.
python experiments/exp06_ablation.py
Output: results/figures/exp6_ablation.png
Atteso: La variante a base fissa ristagna; la variante senza retrazione è instabile; l'Algoritmo 1 completo raggiunge un decadimento stabile a costo controllato.