tz98lab/dlr-ne-ics-securityCódigo de pesquisa que implementa o cálculo de Equilíbrio de Nash de Baixo Posto Dinâmico para jogos de segurança de ICS estocásticos entre ameaças persistentes avançadas e defesas de alvo móvel.
Cálculo de Equilíbrio de Posto Baixo Dinâmico para Jogos Estocásticos entre Ameaças Persistentes Avançadas e Defesa de Alvo Móvel
Artigo Regular, em revisão na Automatica (resubmetido em outubro de 2026)
Este repositório contém a implementação e a validação experimental do algoritmo Equilíbrio de Nash de Posto Baixo Dinâmico (DLR-NE) para o cálculo de equilíbrios de Nash em jogos de segurança de Sistemas de Controle Industrial (ICS) de alta dimensionalidade.
A interação estratégica entre Ameaças Persistentes Avançadas (APTs) e Defesas de Alvo Móvel (MTDs) é modelada como um jogo estocástico de soma zero entre dois jogadores sobre um espaço de estados contínuo de dimensão $n \sim 10^3$–$10^4$. A ideia central é que o acoplamento físico de posto baixo dos canais de ataque e defesa (uma propriedade estrutural inerente à topologia de rede de ICS) possibilita uma aproximação tratável por rede neural de posto baixo da função de valor de equilíbrio, reduzindo a complexidade por iteração de $\mathcal{O}(n^2)$ para $\mathcal{O}(nr^2)$, um ganho de velocidade de $\Theta(n/r^2)$.
| Teorema | Enunciado | Experimento |
|---|---|---|
| Teorema 1 | Limite global de erro de aproximação de posto baixo para a função de valor ótima $V^*$ | Exp. 1 |
| Teorema 2 | Convergência geométrica do DLR-NE com decomposição explícita do erro em regime permanente | Exp. 2 |
| Teorema 3 | Complexidade por iteração $\mathcal{O}(nr^2)$ e ganho de velocidade $\Theta(n/r^2)$ sobre as linhas de base de posto completo | Exp. 3 |
| Corolário 1 | Robustez teórica dos jogos: a sensibilidade do equilíbrio é controlada pelo número de condição $\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 os experimentos são autocontidos e podem ser executados de forma independente. Cada script gera figuras no diretório results/figures/.
Nota sobre Escala: As configurações padrão usam $n=200$ para demonstração rápida. Para reproduzir os resultados em escala completa relatados no artigo ($n \sim 10^3$), modifique o
PowerSystemConfigno topo de cada script (veja os comentários inline).
Valida que o erro de truncamento $|V_{\mathrm{full}} - \widehat{V}r|\infty$ decai com o posto $r$ e está alinhado com a previsão teórica de Eckart-Young-Mirsky.
python experiments/exp01_truncation_error.py
Saída: results/figures/exp1_truncation_error.png
Esperado: O erro medido (círculos azuis) acompanha o limite teórico $L_\phi |w_{\mathrm{out}}^*|2 R{\mathcal{X}} \epsilon_{\mathrm{EYM}}(r)$ (linha tracejada roxa); o espectro de valores singulares mostra decaimento rápido.
Valida a convergência geométrica com taxa $\gamma$ e a vizinhança explícita de erro em regime permanente $\varepsilon_{\mathrm{total}}/(1-\gamma)$.
python experiments/exp02_convergence.py
Saída: results/figures/exp2_convergence.png
Esperado: As curvas de erro primeiro decaem ao longo do envelope $\gamma^k$, depois se achatam em um platô dominado pelo orçamento do laço interno $s^$ (reduzir $s^$ pela metade custa um fator de $\approx 20$ em precisão); o tamanho do lote $N_b$ tem um efeito comparativamente desprezível.
Valida a complexidade por iteração $\mathcal{O}(nr^2)$ e o ganho de velocidade $\Theta(n/r^2)$ sobre as linhas de base FC-NN de posto completo.
python experiments/exp03_complexity.py
Saída: results/figures/exp3_complexity.png
Esperado: O DLR-NE escala linearmente em $n$ (inclinação 1 em log-log), a FC-NN escala quadraticamente (inclinação 2); ganho de velocidade medido em FLOPs $\approx 12\times$ (tempo de execução $\approx 4\times$) em $n=2000, r=10$.
Valida a relação linear $|V(\cdot;\pi_D,\pi_A) - V(\cdot;\tilde{\pi}D,\pi_A)|\infty \le L_\kappa |\Delta S|F$ com uma constante de sensibilidade finita e ajustável por $\beta$, $L\kappa$, certificada pelo número de condição $\kappa(S)$ (um certificado a priori de pior caso).
python experiments/exp04_robustness.py
Saída: results/figures/exp4_robustness.png
Esperado: O desvio de valor é linear em $|\Delta S|_F$ com inclinação decrescente em relação ao peso de regularização espectral $\beta$; $\kappa(S)$ é comprimido ao aumentar $\beta$.
Explora a fronteira de Pareto entre a taxa de compressão e a utilidade da política de equilíbrio.
python experiments/exp05_tradeoff.py
Saída: results/figures/exp5_tradeoff.png
Esperado: Ponto ótimo em $r = 5$: $\approx 94%$ de compressão de parâmetros com $\approx 2.3%$ de perda de utilidade.
Compara três variantes: (i) Algoritmo 1 completo, (ii) base fixa, (iii) sem retração.
python experiments/exp06_ablation.py
Saída: results/figures/exp6_ablation.png
Esperado: A variante de base fixa estagna; a variante sem retração é instável; o Algoritmo 1 completo alcança decaimento estável com custo controlado.