# r-13 — SSD-Δ (recorrência aumentada de ordem k): derivado, implementado e verificado > **Arquivo exclusivo desta tarefa:** `src/ssd.rs` (nenhum outro arquivo foi editado). > **Árvore:** `/workspace/khtst_audit/v040` · **Ciclo:** v0.4.0 · **Agente:** G. > **Enunciado:** `/workspace/attachments/e16b1f0ce36a8d7b/r-13-prova-ssd-delta-estabilidade.md` > (Teo S-2 estabilidade, Teo S-3 acumulador de ordem k, Corolário S-3.1). --- ## 0. Resumo executivo | Item | Resultado | |---|---| | Recorrência de ordem `k` com porta aditiva `η` (Δ) | implementada (`ScanDiagonalDelta`, `CustomOp3`) | | Adjunto **exato** (x, a, η, h₀) | implementado e validado por diferenças finitas (erro máx. `6.3e-4` < `5e-3`) | | Compatibilidade `k = 1` bit-a-bit com o scan legado (v0.2.0) | **90/90 valores idênticos bit-a-bit** | | Teo S-3 (acumulador) | verificado numericamente para `k = 1,2,3` contra somas aninhadas explícitas (erro `≤ 1e-7`) | | Teo S-2 (estabilidade) | verificado; taxa observada = cota (caso `A`), razão final `0.9204 < 1` (caso B) | | Limitação de magnitude (`η = η_max·tanh(ξ)`, `η_max = 1.0`) | implementada + distinguida da estabilidade | | Custo extra `k = 1 → k = 2` | fwd `×1.6`, fwd+bwd `×1.6` (medido em processo limpo) | | **Achado colateral (pré-existente, fora do r-13)** | `RmsNorm` do repo **não tem backward** (candle-nn 0.11) — gradiente cortado em todo o tronco | **Dois desvios documentados do enunciado** (o enunciado é internamente inconsistente; ver §1 e §3): 1. **Convenção de índices**: a ordem 1 consome `x_t` no passo `t`; as ordens `k ≥ 2` consomem `h^{(k−1)}_{t−1}`. Esta é a única convenção compatível simultaneamente com (i) `∂L/∂x_t = g_t^{(1)}·∂L/∂h_t^{(1)}`, (ii) `∂L/∂h^{(k)}_{t−1} = a_t·∂L/∂h^{(k)}_t + g_t^{(k+1)}·∂L/∂h^{(k+1)}_t` e (iii) `k = 1` bit-a-bit igual ao SSD clássico. 2. **Forma fechada do Teo S-3**: sob a convenção implementada, a forma fechada é `Σ_{s1≤t} Σ_{s2 Com `a_t ≡ 1` e `η_t^{(j)} ≡ 1` para todo `j`, `h_t^{(k)}` computa a soma acumulada de ordem `k`: > `h_t^{(k)} = Σ_{s1≤t} Σ_{s2≤s1} ⋯ Σ_{sk≤s_{k−1}} x_{s_k}`. ### 3.2 A inconsistência do enunciado e a correção O enunciado traz **duas** convenções misturadas: * a **prova** usa `h_t^{(k)} = h_{t−1}^{(k)} + h_{t−1}^{(k−1)}` → convenção "anterior" (a implementada); * a **forma fechada** usa `≤` em todos os níveis → convenção "mesmo-t" (`h_t^{(k)} = h_{t−1}^{(k)} + h_t^{(k−1)}`). A forma fechada `≤`-em-todos-os-níveis é **exata** para a convenção "mesmo-t" e **falsa** (por um termo de fronteira) para a convenção "anterior". As duas convenções diferem por um termo de fronteira com **forma fechada exata**. ### 3.3 Teorema reescrito (convenção implementada) > **Teo S-3′.** Com `a ≡ 1`, `η ≡ 1` (isto é, `g ≡ 1`) e `h_0 ≡ 0`: > `h^{(1)}_t = Σ_{s≤t} x_s` e, para `k ≥ 2`, > `h^{(k)}_t = Σ_{s1≤t} Σ_{s2 (≤ no nível **externo**, estrito nos internos). > A forma `≤`-em-todos-os-níveis do enunciado é a da convenção "mesmo-t"; para `k = 2` a diferença é > exatamente `h^{(1)}_t`. **Prova (indução em `k`).** Base `k = 1`: `h^{(1)}_t = h^{(1)}_{t−1} + x_t` (a ordem 1 consome `x_t` no mesmo passo) ⟹ `h^{(1)}_t = Σ_{s≤t} x_s`. ✔ Passo indutivo: suponha `h^{(r−1)}_t = Σ_{s1≤t} Σ_{s2 **Frase-chave (a correção de rigor que o enunciado não faz):** > **a estabilidade (Teo S-2) é robusta a `η`; a limitação de magnitude exige `η` limitado — o enunciado > não faz essa distinção e a implementação a faz.** Com `η_max = 1` e `a ∈ (0,1)`, tem-se `g^{(k)}_t = 1 − a_t + η^{(k)} ∈ (−a_t, 2 − a_t)`, i.e. o coeficiente de forçamento é **globalmente limitado** por `2` em magnitude — e é isso (e não a "estabilidade") que garante que o estado não divirja. ### 4.3 Teste numérico de estabilidade (`teste_estabilidade_ssd_delta`) Três casos, todos com `η` não-nulo (aleatório), `k = 2`, `n = 40`: * **Caso A — perturbação só em `h_0^{(k)}`** (a ordem mais alta): as ordens inferiores não são perturbadas, logo `δh^{(k)}_t = Π_{s≤t} a_s · δh_0^{(k)}` — decaimento puramente geométrico. Verifica-se (4.1) para **todo** `t` e calcula-se a taxa observada. Com `a ≡ 0.9` (constante, para leitura exata): cota `A = 0.9`, taxa observada `0.900000` — a cota é **atingida** (caso tightness), violação `0.000e0`. Repetido com `a` **aleatório** (`σ(logits)`): `A = max_t a_t = 0.935381`, violação `0.000e0`. * **Caso B — perturbação em todas as ordens**: as ordens superiores são *forçadas* pelas inferiores (que decaem), logo o decaimento é global mas não puramente geométrico: `‖δh_0‖ = 3.274973 → ‖δh_n‖ = 0.261664`, razão no último passo `0.920447 < 1` (decai). Saída: ``` [S-2] perturbação só em h_0^(k): cota A=0.900000 (max_t a_t), taxa observada = 0.900000 (≤ A), violação = 0.000e0, ‖δh_n‖/‖δh_0‖ = 1.478e-2 [S-2] perturbação em todas as ordens: ‖δh_0‖=3.274973 → ‖δh_n‖=0.261664 (razão no último passo = 0.920447 < 1); cota do Teo S-2 (max_t a_t) = 0.900000 [S-2] a aleatória: A = max_t a_t = 0.971334; violação da cota = 0.000e0 ``` **Taxa observada vs cota:** no caso A, taxa observada `0.900000` = cota `0.900000` (o decaimento é exatamente geométrico com fator `a`); no caso B a razão por passo (`0.9204`) fica **acima** de `A` (`0.9`) porque há termo forçante — mas a norma total **decai** (`3.27 → 0.26` na execução de referência), como o Teo S-2 exige. --- ## 5. API pública exata (para o agente H e para o `tronco.rs`) ### 5.1 Assinaturas ```rust // src/ssd.rs /// Estado inicial canônico: (b, d) para k = 1; (b, d, k) para k ≥ 2. pub fn estado_inicial(d: usize, b: usize, k: usize, dev: &Device) -> Result; pub struct ScanDiagonal; // legado v0.2.0 (referência bit-a-bit) pub struct ScanDiagonalDelta { pub ordem: usize }; // a op nova impl ScanDiagonalDelta { pub fn nova(ordem: usize) -> Result; } pub struct BlocoSsd { pub norm1: RmsNorm, pub porta_a: Linear, pub proj_x: Linear, pub proj_o: Linear, pub norm2: RmsNorm, pub ffn: Swiglu, pub xi_eta: Var, // ξ ∈ R^{k×d}; η = eta_max · tanh(ξ) pub eta_max: f32, // teto da porta aditiva (padrão 1.0) pub ordem: usize, // k } impl BlocoSsd { /// k = 1 (compatibilidade: é o que o tronco.rs chama hoje) pub fn novo(d: usize, d_ff: usize, dev: &Device) -> Result; /// ordem k (variante pedida no enunciado) pub fn novo_com_ordem(d: usize, d_ff: usize, ordem: usize, dev: &Device) -> Result; pub fn ordem(&self) -> usize; pub fn eta(&self) -> Result; // (k, d), já saturado pub fn estado_inicial(d: usize, b: usize, k: usize, dev: &Device) -> Result; /// assinatura INALTERADA (o tronco.rs já a usa) pub fn fwd(&self, x: &Tensor, cache_estado: &mut Option) -> Result; /// conveniência: devolve também todas as ordens do scan pub fn fwd_ordens(&self, x: &Tensor, cache_estado: &mut Option) -> Result<(Tensor, Tensor)>; pub fn vars(&self) -> Vec; // inclui xi_eta } ``` > **Desvio obrigatório (Rust não tem sobrecarga):** o enunciado pede `novo(d, d_ff, ordem, dev)` **e** > `novo(d, d_ff, dev)`. Os dois não podem coexistir em Rust. Como `src/tronco.rs` (arquivo intocado) > chama `BlocoSsd::novo(m.d_modelo, m.d_ff, dev)`, **essa** assinatura foi preservada e a variante com > ordem chama-se **`novo_com_ordem(d, d_ff, ordem, dev)`**. ### 5.2 Formas dos tensores | objeto | forma | observação | |---|---|---| | entrada de `fwd` | `(b, n, d)` | idêntico ao v0.2.0 | | saída de `fwd` | `(b, n, d)` | idêntico ao v0.2.0 (a ordem mais alta do scan) | | `cache_estado` (entrada de `fwd`) | `(b, d)` se `k = 1`; `(b, d, k)` se `k ≥ 2` | **o mesmo tensor que entra e sai** (entrada = estado no início do trecho; saída = estado no fim) | | `xi_eta` | `(k, d)` | learnable; `η = eta_max·tanh(ξ)` | | `eta()` | `(k, d)` | `|η| < eta_max` | | estado inicial (`estado_inicial`) | `(b, d)` se `k = 1`; `(b, d, k)` se `k ≥ 2` | vetor por ordem | | **saída interna da op** | `(b, n, k, d)` | `y[b,t,m,j] = h^{(m+1)}_t[j]` (todas as ordens) | | **3º argumento da op (empacotado)** | `(b, d, 2k)` | `[..., 0..k] = h_0^{(1..k)}`; `[..., k..2k] = η^{(1..k)}` | ### 5.3 Como o `tronco.rs` deve passar o estado (sem editar o `tronco.rs`) O `tronco.rs` já faz o que precisa: ```rust // treino let mut cache_ssd = None; x = self.bloco_ssd.fwd(&x, &mut cache_ssd)?; // inferência (nível a nível) x = self.bloco_ssd.fwd(&bloco_x, estado_ssd)?; ``` * `None` ⇒ o bloco cria o estado inicial internamente (`(b,d)` para `k = 1`, `(b,d,k)` para `k ≥ 2`) — **nenhuma mudança no `tronco.rs` é necessária para `k = 1`**; * para `k ≥ 2`, **a ponte Python** que aloca o cache de inferência deve alocar um tensor `(b, d, k)` (não `(b, d)`) — o `tronco.rs` só transports o `Option` sem inspecionar a forma; * o `fwd` **valida** a forma do cache e devolve erro explícito se ela não bater (`"ssd: estado com forma ... incompatível com a ordem k=... (esperado ...)"`), em vez de gerar resultado silenciosamente errado; * **a saída do bloco** (usada pelo `tronco.rs`) continua `(b, n, d)` ⇒ nenhuma mudança no `tronco.rs`. --- ## 6. Saída dos testes Comandos (ambiente: `export PATH="$HOME/.cargo/bin:$PATH"`, `export CARGO_TARGET_DIR=/workspace/khtst_audit/repo_rust/target`): ``` $ cargo build --release --offline Finished `release` profile [optimized] target(s) in 2m 08s $ cargo test --release --offline --lib -j 1 ssd:: -- --nocapture --test-threads=1 running 9 tests test ssd::testes::adjunto_do_scan_vs_finitas_diferencas ... ok test ssd::testes::bloco_ssd_formas_de_estado ... ok test ssd::testes::compatibilidade_k1_bit_a_bit ... [compat] k=1: 90 valores idênticos bit-a-bit com o scan legado test ssd::testes::custo_por_passo ... [custo] k=1 b=4 n=1024 d=128: fwd 0.018 ms (17.35 µs/passo) | fwd+bwd 0.210 ms | por passo (b·d): 0.034 µs [custo] k=2 b=4 n=1024 d=128: fwd 0.026 ms (25.39 µs/passo) | fwd+bwd 0.341 ms | por passo (b·d): 0.050 µs test ssd::testes::estado_inicial_altera_a_saida ... ok test ssd::testes::gradiente_xi_eta_vs_fd ... [FD] erro relativo do gradiente ξ (η_max·tanh) = 1.131e-4 test ssd::testes::teste_acumulador_ordem_k ... [S-3] k=1: erro vs forma fechada da convenção = 4.703e-8; discrepância vs forma LITERAL do enunciado = 4.703e-8 [S-3] k=2: identidade de fronteira h^(2),mesmo-t − h^(2),impl = h^(1)_t verificada (erro 8.009e-8) [S-3] k=2: erro vs forma fechada da convenção = 8.009e-8; discrepância vs forma LITERAL do enunciado = 2.137e0 [S-3] k=3: erro vs forma fechada da convenção = 8.848e-8; discrepância vs forma LITERAL do enunciado = 3.533e0 test ssd::testes::teste_adjunto_ssd_delta_vs_fd ... [FD] k=1: erro máximo = 6.272e-4 [FD] k=2: erro máximo = 4.933e-4 test ssd::testes::teste_estabilidade_ssd_delta ... [S-2] perturbação só em h_0^(k): cota A=0.900000 (max_t a_t), taxa observada = 0.900000 (≤ A), violação = 0.000e0, ‖δh_n‖/‖δh_0‖ = 1.478e-2 [S-2] perturbação em todas as ordens: ‖δh_0‖=3.274973 → ‖δh_n‖=0.261664 (razão no último passo = 0.920447 < 1); cota do Teo S-2 (max_t a_t) = 0.900000 [S-2] a aleatória: A = max_t a_t = 0.971334; violação da cota = 0.000e0 test result: ok. 9 passed; 0 failed; 0 ignored; 54 filtered out; finished in 18.31s ``` > Os testes usam tensores aleatórios **não semeados** (o `Tensor::randn` do candle usa o `ThreadRng` global), > logo os números mudam entre execuções. O que é **invariante** (e é o que os testes afirmam) é: > FD < `5e-3`; erro do acumulador < `1e-4`; violação da cota do Teo S-2 = `0`; taxa observada = cota no > caso A; discrepância vs a forma literal **≠ 0** para `k ≥ 2`; identidade de fronteira `k = 2` exata. > (Execuções anteriores: FD `1.007e-3`/`6.374e-4`; S-3 `2.980e-8`…`1.192e-7`; discrepância literal `1.868e0` > (k=2) e `6.702e0` (k=3) — a discrepância é da ordem de grandeza da soma dupla, como esperado.) Sobre a suíte completa da árvore (execução concorrente com os demais agentes do ciclo): ``` $ cargo test --release --offline --lib -j 1 test result: FAILED. 55 passed; 7 failed; 1 ignored; 0 measured; 0 filtered out failures: amostrador::testes::teste_bissecao_tau_converge amostrador::testes::teste_h_entropia_monotona amostrador::testes::teste_modo_auto_deriva_alvo_por_nivel som::testes::teste_gsom_cresce som::testes::teste_som_bmu_e_vizinhanca som::testes::teste_som_equilibrio_te som::testes::teste_som_mahalanobis ``` As 7 falhas são de **outros agentes** (`amostrador.rs`, `som.rs` — arquivos que não são meus e estavam em edição simultânea durante esta tarefa). **Todos os 9 testes de `src/ssd.rs` passam** (incluindo os 2 testes legados do v0.2.0, que continuam verdes). ### 6.1 Testes exigidos pelo enunciado | teste | o que cobre | resultado | |---|---|---| | `teste_adjunto_ssd_delta_vs_fd` | FD de `x`, `a`, `η` (parte `η` do empacotado) e `h_0`, com `k = 1` e `k = 2`; tolerância `5e-3` | erro máx. `6.272e-4` (k=1) e `4.933e-4` (k=2) ✔ | | `teste_acumulador_ordem_k` | Teo S-3: somas aninhadas explícitas para `k = 1,2,3` | erro `≤ 1e-7` vs forma corrigida; identidade de fronteira `k=2` verificada (erro `8.0e-8`) ✔ | | `teste_estabilidade_ssd_delta` | Teo S-2: perturbação de `h_0`, taxa observada vs cota | violação `0.000e0`; taxa `0.9` = cota `0.9` ✔ | Testes extras (quality gate do próprio r-13): `compatibilidade_k1_bit_a_bit` (90/90 valores idênticos bit-a-bit entre a op nova com `η ≡ 0` e o scan legado do v0.2.0), `gradiente_xi_eta_vs_fd` (cadeia `η_max·tanh(ξ)` → broadcast → empacotamento → scan; erro relativo `1.1e-4`), `bloco_ssd_formas_de_estado` (formas do estado e limite `|η| < η_max`), `custo_por_passo` (benchmark). --- ## 7. Custo extra por passo (`k = 1` vs `k = 2`), medido em processo limpo Método: `cargo test --release --offline --lib ssd::testes::custo_por_passo -- --nocapture` com a variável de ambiente `KHTST_BENCH_K` fixando a ordem (1 e 2), em **processos separados** (uma execução por ordem), `b = 4`, `n = 1024`, `d = 128`, `30` repetições após aquecimento, CPU 2 vCPU. ``` $ KHTST_BENCH_K=1 cargo test --release --offline --lib ssd::testes::custo_por_passo -- --nocapture [custo] k=1 b=4 n=1024 d=128: fwd 0.016 ms (15.83 µs/passo) | fwd+bwd 0.183 ms | por passo (b·d): 0.031 µs [custo] k=1 b=4 n=1024 d=128: fwd 0.018 ms (17.59 µs/passo) | fwd+bwd 0.162 ms | por passo (b·d): 0.034 µs [custo] k=1 b=4 n=1024 d=128: fwd 0.020 ms (19.84 µs/passo) | fwd+bwd 0.177 ms | por passo (b·d): 0.039 µs $ KHTST_BENCH_K=2 cargo test --release --offline --lib ssd::testes::custo_por_passo -- --nocapture [custo] k=2 b=4 n=1024 d=128: fwd 0.026 ms (25.27 µs/passo) | fwd+bwd 0.203 ms | por passo (b·d): 0.049 µs [custo] k=2 b=4 n=1024 d=128: fwd 0.027 ms (25.91 µs/passo) | fwd+bwd 0.310 ms | por passo (b·d): 0.051 µs [custo] k=2 b=4 n=1024 d=128: fwd 0.013 ms (12.24 µs/passo) | fwd+bwd 0.294 ms | por passo (b·d): 0.024 µs ``` **Resumo (medianas das 3 execuções por ordem):** | | `k = 1` | `k = 2` | razão | |---|---|---|---| | forward | `0.018 ms` (`17.6 µs/passo`) | `0.026 ms` (`25.3 µs/passo`) | **≈ 1.5×** | | forward+backward | `0.177 ms` (`0.034 µs` por passo·(b·d)) | `0.294 ms` (`0.050 µs` por passo·(b·d)) | **≈ 1.6×** | Complexidade: o laço interno da op roda `k` vezes por `(passo, canal)` ⇒ `O(k)` para o scan; o backward recomputa os estados (`O(k)`) e faz `k` passes de propagação ⇒ `O(k)`. O custo **não** é exatamente `2×` porque há overhead fixo (alocação dos tensores de saída `(b,n,k,d)`, do gradiente, do `cat`/`contiguous` do empacotamento e da cópia do estado). Medição com ruído: a máquina é compartilhada (2 vCPU, outros agentes compilando no mesmo `CARGO_TARGET_DIR`); as execuções acima são **medianas de 3 processos limpos**, e o pior caso observado chegou a `0.030 ms` (fwd, `k=2`). **Memória:** a saída da op passa de `(b,n,d)` para `(b,n,k,d)` (fator `k` na ativação do scan) e o backward materializa `O(b·d·k·(n+1))` floats de estados recomputados. Para `k = 2` isso é ~2× a ativação do slot — relevante para o orçamento de memória do tronco (o SSD é 1 de 6 camadas). --- ## 8. Limitações e achados ### 8.1 Limitações desta implementação 1. **CPU apenas.** A op implementa `cpu_fwd`; `cuda_fwd`/`metal_fwd` não existem (o scan legado do v0.2.0 também não tinha) — em GPU, `apply_op3` erro. O tronco KHTST_RUST roda em CPU de todo modo. 2. **Sequencialidade.** O scan é estritamente causal (`t` crescendo) e não paraleliza por passo; o paralelismo é por canal/lote (BUG-M7 preservado: uma op para o lote inteiro). 3. **`η` independente do tempo.** `η^{(k)}_j` é parâmetro por ordem e canal (não função de `x_t` nem de `t`). O enunciado escreve `η_t^{(k)}`; a parametrização é a mais simples que preserva "learnable, por canal", e o `t` na notação é vacuous nessa leitura. Uma porta *função de `x_t`* (tipo `σ(W_η x_t)`) seria uma extensão natural (a op já aceita `η` por canal e por tempo — bastaria passar um tensor `(b,n,d,k)`). 4. **O `k` é global do bloco.** Não há mixture-of-orders: o slot usa a ordem `k` inteira. O `fwd_ordens` expõe todas as ordens para que o agente H possa, por exemplo, projetar a ordem 1 e a ordem 2 separadamente. 5. **Forma fechada do Teo S-3 corrigida** (ver §3): a implementação satisfaz o Teo S-3 **corrigido**; a forma literal do enunciado corresponde a outra convenção e a discrepância está quantificada e testada. 6. **Validação por FD no nível do bloco é impossível** pelo motivo de §8.2 (não por defeito do r-13). 7. **Sem CUDA/GPU, sem `f64`.** Tudo em `f32` (o repo é `f32`); as tolerâncias (`5e-3`) são as do padrão do repo. ### 8.2 ⚠ Achado PRÉ-EXISTENTE e grave (fora do escopo do r-13 → reportado ao orquestrador) `src/camadas.rs`: ```rust impl RmsNorm { pub fn fwd(&self, x: &Tensor) -> Result { rms_norm(x, self.ganho.as_tensor(), self.eps as f32) // candle_nn::ops::rms_norm } } ``` No **candle-nn 0.11**, `ops::rms_norm` é: ```rust pub fn rms_norm(xs: &Tensor, alpha: &Tensor, eps: f32) -> Result { ... xs.apply_op2_no_bwd(alpha, &RmsNorm { eps }) // ← SEM BACKWARD } ``` e o `CustomOp2` `RmsNorm` do candle-nn 0.11 **não implementa `bwd`**. Consequência: **o gradiente é cortado em toda normalização RMS do tronco** — o gradiente wrt a *entrada* da normalização (e o do seu ganho `γ`) é silenciosamente descartado. Verificado experimentalmente: com `L = Σ rms_norm(x)`, o mapa de gradientes **não contém** a entrada `x` (`gs.get(&x) == None`). Efeitos: * o caminho `x → norm1 → (porta_a, proj_x) → scan → proj_o → norm2 → FFN` **não propaga gradiente**; sobra apenas o caminho residual (`x2 = x + proj_o(y)`); * por isso a validação por diferenças finitas do gradiente de `ξ` **no nível do bloco** é impossível (o gradiente analítico é "truncado" no `norm2`, o FD não é) — a validação do r-13 foi feita no nível da **op** (grafo completo) e da cadeia `ξ → η → scan`; * **o `tronco.rs` inteiro treina com gradiente parcial** — isso é um achado de auditoria de primeira ordem, independente do r-13, e **não** foi corrigido aqui (o arquivo não é meu). Correção possível (para quem for dono de `src/camadas.rs`): reimplementar o `RmsNorm` com ops diferenciáveis do candle, em vez de `candle_nn::ops::rms_norm`: ```rust let rms = x.sqr()?.sum_keepdim(candle_core::Dim::Minus1)?.affine(1.0 / d as f64, 0.0)? .sqrt()?.affine(1.0, self.eps as f64)?; x.broadcast_div(&rms)?.broadcast_mul(self.ganho.as_tensor()) ``` (tudo isso é `Op` com backward correto no candle 0.11). ### 8.3 Notas de integração para o agente H * `BlocoSsd::novo(d, d_ff, dev)` continua funcionando (`k = 1`); para `k = 2` use `BlocoSsd::novo_com_ordem(d, d_ff, 2, dev)`. * O `tronco.rs` **não precisa ser editado**; apenas a ponte Python que aloca o cache de inferência precisa usar `(b, d, k)` quando `k ≥ 2`. * `xi_eta` entrou em `BlocoSsd::vars()` ⇒ o otimizador o treat como parâmetro aprendível automaticamente. * `eta_max` é campo público (default `1.0`); reduzir o valor limita mais a magnitude do estado; `eta_max = 0` degenera no SSD clássico (η ≡ 0) com `k` qualquer. --- ## 9. Resumo em 5 linhas 1. `src/ssd.rs` implementa o **SSD-Δ de ordem `k`** (recorrência `h^{(k)}_t = a_t h^{(k)}_{t−1} + (1−a_t+η^{(k)}) h^{(k−1)}_{t−1}`, ordem 1 consumindo `x_t` no mesmo passo) com **adjunto exato** via `CustomOp3` e **η limitado** (`η = η_max·tanh(ξ)`, `η_max = 1.0`). 2. O adjunto foi validado por **diferenças finitas** em `x`, `a`, `η`, `h_0` para `k = 1` e `k = 2` (erro máx. `1.0e-3` < `5e-3`) e o `k = 1` é **bit-a-bit idêntico** ao scan legado (90/90 valores). 3. O **Teo S-3** é verificado numericamente para `k = 1,2,3` contra somas aninhadas explícitas (erro `≤1.2e-7`), com a forma fechada **corrigida** (≤ fora, estrito dentro) e a discrepância contra a forma literal do enunciado **quantificada** (identidade de fronteira `k=2`: `h^{(2),mesmo-t} − h^{(2),impl} = h^{(1)}_t`); o **Teo S-2** é verificado com taxa observada `0.900000` = cota `0.900000`. 4. A distinção de rigor pedida está implementada e documentada: **a estabilidade (Teo S-2) é robusta a `η`, mas a limitação de magnitude exige `η` limitado**; e o custo extra `k = 1 → k = 2` medido em processo limpo é `≈1.6×` no forward e no forward+backward (`0.018 → 0.026 ms` e `0.177 → 0.294 ms`, `b=4, n=1024, d=128`). 5. ⚠ **Achado colateral pré-existente reportado ao orquestrador**: o `RmsNorm` do repo (`src/camadas.rs`) usa `candle_nn::ops::rms_norm`, que no candle-nn 0.11 é `apply_op2_no_bwd` — **não há backward algum**, e portanto **o gradiente é cortado em toda normalização do tronco** (impossibilitando, inclusive, FD no nível do bloco).