tz98lab/dlr-ne-ics-securityCódigo de investigación que implementa el cálculo de Equilibrio de Nash Dinámico de Bajo Rango para juegos de seguridad ICS estocásticos entre amenazas persistentes avanzadas y defensas de objetivo móvil.
Cálculo de Equilibrio Dinámico de Bajo Rango para Juegos Estocásticos entre Amenazas Persistentes Avanzadas y Defensa de Objetivo Móvil
Artículo Regular, en revisión en Automatica (reenviado en octubre de 2026)
Este repositorio contiene la implementación y validación experimental del algoritmo Equilibrio de Nash Dinámico de Bajo Rango (DLR-NE) para calcular equilibrios de Nash en juegos de seguridad de Sistemas de Control Industrial (ICS) de alta dimensión.
La interacción estratégica entre Amenazas Persistentes Avanzadas (APT) y Defensas de Objetivo Móvil (MTD) se modela como un juego estocástico de suma cero de dos jugadores sobre un espacio de estados continuo de dimensión $n \sim 10^3$–$10^4$. La idea clave es que el acoplamiento físico de bajo rango de los canales de ataque y defensa (una propiedad estructural inherente a la topología de red ICS) permite una aproximación tratable mediante redes neuronales de bajo rango de la función de valor de equilibrio, reduciendo la complejidad por iteración de $\mathcal{O}(n^2)$ a $\mathcal{O}(nr^2)$, una aceleración de $\Theta(n/r^2)$.
| Teorema | Enunciado | Experimento |
|---|---|---|
| Teorema 1 | Cota global del error de aproximación de bajo rango para la función de valor óptima $V^*$ | Exp. 1 |
| Teorema 2 | Convergencia geométrica de DLR-NE con descomposición explícita del error en estado estacionario | Exp. 2 |
| Teorema 3 | Complejidad por iteración $\mathcal{O}(nr^2)$ y aceleración $\Theta(n/r^2)$ sobre las líneas base de rango completo | Exp. 3 |
| Corolario 1 | Robustez teórico-de-juegos: la sensibilidad del equilibrio está controlada por el número de condición $\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
Todos los experimentos son autocontenidos y pueden ejecutarse de forma independiente. Cada script genera figuras en el directorio results/figures/.
Nota sobre la Escala: Las configuraciones predeterminadas usan $n=200$ para una demostración rápida. Para reproducir los resultados a escala completa reportados en el artículo ($n \sim 10^3$), modifique el
PowerSystemConfigal inicio de cada script (consulte los comentarios en línea).
Valida que el error de truncamiento $|V_{\mathrm{full}} - \widehat{V}r|\infty$ decae con el rango $r$ y concuerda con la predicción teórica de Eckart-Young-Mirsky.
python experiments/exp01_truncation_error.py
Salida: results/figures/exp1_truncation_error.png
Esperado: El error medido (círculos azules) sigue la cota teórica $L_\phi |w_{\mathrm{out}}^*|2 R{\mathcal{X}} \epsilon_{\mathrm{EYM}}(r)$ (línea discontinua púrpura); el espectro de valores singulares muestra una rápida decadencia.
Valida la convergencia geométrica con tasa $\gamma$ y la vecindad explícita de error en estado estacionario $\varepsilon_{\mathrm{total}}/(1-\gamma)$.
python experiments/exp02_convergence.py
Salida: results/figures/exp2_convergence.png
Esperado: Las curvas de error primero decaen a lo largo de la envolvente $\gamma^k$, luego se estabilizan en una meseta dominada por el presupuesto del bucle interno $s^$ (reducir $s^$ a la mitad cuesta un factor de $\approx 20$ en precisión); el tamaño del lote $N_b$ tiene un efecto comparativamente despreciable.
Valida la complejidad por iteración $\mathcal{O}(nr^2)$ y la aceleración $\Theta(n/r^2)$ sobre las líneas base de FC-NN de rango completo.
python experiments/exp03_complexity.py
Salida: results/figures/exp3_complexity.png
Esperado: DLR-NE escala linealmente en $n$ (pendiente 1 en log-log), FC-NN escala cuadráticamente (pendiente 2); aceleración medida en FLOPs $\approx 12\times$ (tiempo de reloj $\approx 4\times$) en $n=2000, r=10$.
Valida la relación lineal $|V(\cdot;\pi_D,\pi_A) - V(\cdot;\tilde{\pi}D,\pi_A)|\infty \le L_\kappa |\Delta S|F$ con una constante de sensibilidad finita y ajustable por $\beta$, $L\kappa$, certificada por el número de condición $\kappa(S)$ (un certificado a priori del peor caso).
python experiments/exp04_robustness.py
Salida: results/figures/exp4_robustness.png
Esperado: La desviación del valor es lineal en $|\Delta S|_F$ con pendiente decreciente en el peso de regularización espectral $\beta$; $\kappa(S)$ se comprime al aumentar $\beta$.
Explora la frontera de Pareto entre la tasa de compresión y la utilidad de la política de equilibrio.
python experiments/exp05_tradeoff.py
Salida: results/figures/exp5_tradeoff.png
Esperado: Punto óptimo en $r = 5$: $\approx 94%$ de compresión de parámetros con $\approx 2.3%$ de pérdida de utilidad.
Compara tres variantes: (i) Algoritmo 1 completo, (ii) base fija, (iii) sin retracción.
python experiments/exp06_ablation.py
Salida: results/figures/exp6_ablation.png
Esperado: La variante de base fija se estanca; la variante sin retracción es inestable; el Algoritmo 1 completo logra una decadencia estable a un costo controlado.