v0.8.0: análise/prova/teste das 4 propostas Qwen3.8 (r-33) — Newton analítico no verificador (convexidade em gamma=1/T), árvore pós-ordem iterativa bit-a-bit com detecção de ciclos, Cayley exato no FNH (4,1× mais rápido), MoE vetorizada com gradiente RESTAURADO (bug v080-1) — 85/85 gates, 99/99 cargo

Cargo.lock

@@ -734,7 +734,7 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "khtst-rust"
-version = "0.7.0"
+version = "0.8.0"
 dependencies = [
  "anyhow",
  "built",

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "khtst-rust"
-version = "0.7.0"
+version = "0.8.0"
 edition = "2021"
-description = "KHTST_RUST — NCM com verificador calibrado, treino conjunto Pensamento↔backbone, MoEs redirecionáveis com atenção própria e autoajuste por telemetria"
+description = "KHTST_RUST — provas e testes das propostas Qwen3.8: Newton analítico (verificador), árvore pós-ordem iterativa, Cayley exato (FNH), MoE vetorizada com gradiente restaurado"
 license = "Apache-2.0"
 
 [lib]

docs/memorias/r-33-analise-provas-qwen-v080.md

@@ -0,0 +1,460 @@
+# r-33 — Análise, Provas e Testes das Propostas do Agente Qwen3.8 (v0.8.0)
+
+**Escopo**: o usuário pediu *analisar, provar e testar* as 4 propostas de código
+geradas pelo agente Qwen3.8 (verificador.rs, arvore_pesos.rs, fnh.rs,
+moe_redirecionavel.rs), mantendo o princípio da casa: **nenhuma funcionalidade
+SOTA eficaz é removida**; toda mudança com prova matemática, lógica e de lógica
+computacional; provas em markdown; medições honestas.
+
+**Metodologia**: (i) verificação matemática simbólica de cada proposta antes de
+qualquer código; (ii) confronto com oráculos independentes (diferenças finitas,
+Gauss–Jordan em f64, SVD/NumPy, implementação de referência v0.6.0/v0.7.0);
+(iii) implementação apenas do que sobrevive a (i)+(ii), como **adição** aos
+métodos existentes (que permanecem como referência/rede de segurança);
+(iv) testes de regressão + determinismo 3×; (v) medição de custo.
+
+**Veredito sumário**:
+
+| # | Proposta | Veredito | Correções necessárias | Ganho medido |
+|---|----------|----------|----------------------|--------------|
+| 1 | Newton-Raphson na calibração de temperatura | **IDEIA VÁLIDA, CÓDIGO ERRADO** (2 erros matemáticos) | sinal de dL/dT invertido; 1ª diferença usada como 2ª derivada | 14 vs ~44 avaliações; 1,5× tempo |
+| 2 | Agregação fundo-topo iterativa (pós-ordem) | **VÁLIDA com correções de robustez** | sem guarda contra duplicatas/ciclos; sem verificação de alcançabilidade | bit-a-bit igual, sem clones, pilha-safe em 100k nós |
+| 3 | Rotação via Transformada de Cayley | **IDEIA VÁLIDA, CÓDIGO INCOMPILÁVEL/IMPRóprio** | `Tensor::inv()` não existe em candle 0.11; convenção de sinal equivale a `expm(−A)` | 4,1× mais rápido que polar, δ_ort ≤ 8,9e-7 |
+| 4 | Roteamento/perda auxiliar "na GPU" em ops de tensor | **IDEIA VÁLIDA, ESBOÇO INCOMPLETO** (`unimplemented!`) | implementação real revelou o **bug v080-1**: a `fwd` v0.6.0 seccionava o grafo de autograd | gradiente restaurado; MoE −88,7% vs pequena −23,5% |
+
+Além das 4 propostas, o processo expôs **2 bugs pré-existentes** (v080-2 no
+`debug_assert` do quantizador; leitura confundida da ablação JEPA v0.6.0) e
+**3 erros meus próprios durante a implementação** (§6 — catalogados com
+causa-raiz, como manda a tradição r-07/r-27).
+
+---
+
+## §2 — Proposta 1: Newton-Raphson na calibração de temperatura (verificador.rs)
+
+### 2.1 Errata da proposta original
+
+A proposta calculava:
+
+```text
+dl_dt   = (ez − z_target) / (t·t)          // (A)
+d2l_dt2 = (l_pert − l) / eps               // (B)
+```
+
+**(A) tem o sinal INVERTIDO.** Derivação direta (Teo N-1 abaixo):
+`L'(T) = (z_y − E_p[z])/T²`, e não `(E_p[z] − z_y)/T²`.
+
+**(B) não é a segunda derivada.** `[L(T+ε) − L(T)]/ε ≈ L'(T)` é a **primeira**
+diferença (a segunda diferença correta seria `[L(T+ε) − 2L(T) + L(T−ε)]/ε²`).
+
+**Consequência combinada**: com o sinal errado em (A) e (B) ≈ L'(T), o passo
+de Newton computado é `Δ = dl_dt/d2l_dt2 ≈ (−L')/(L') = −1`, isto é, **T ← T+1
+a cada iteração** até esbarrar no clamp 10 — a iteração "converge" para o teto
+do colchão em vez de para o mínimo. Um teste de direção (superconfiante ⇒
+L'(1) < 0) captura o erro imediatamente; a proposta não incluía tal teste.
+
+### 2.2 Teo N-1 (derivadas analíticas) ∎
+
+Seja `L(T) = (1/n)·Σᵢ [−z_{i,yᵢ}/T + log Σⱼ exp(z_{i,j}/T)]` e
+`pᵢ = softmax(zᵢ/T)`. Então:
+
+1. `L'(T) = médiaᵢ (z_{i,yᵢ} − E_{pᵢ}[zᵢ]) / T²`
+2. `L''(T) = médiaᵢ [Var_{pᵢ}(zᵢ) − 2T·(z_{i,yᵢ} − E_{pᵢ}[zᵢ])] / T⁴`
+
+**Prova.** Por amostra: `d/dT[−z_y/T] = z_y/T²` e
+`d/dT[log Σⱼ e^{z_j/T}] = −E_p[z]/T²` (derivada do log-partition com pesos
+`dp_j/dT = p_j(E_p[z] − z_j)/T²`); somando, (1). Para (2), deriva-se
+`d/dT E_p[z] = (E_p[z]² − E_p[z²])/T² = −Var_p[z]/T²` e aplica a regra do
+produto em `(z_y − E_p[z])·T⁻²`:
+`L''(T) = Var_p[z]/T⁴ − 2(z_y−E_p[z])/T³`, que é (2) reunido sobre T⁴. No
+ótimo `L'(T*)=0 ⇒ z_y = E_p[z]` nas amostras (em média), logo
+`L''(T*) = média Var_{p*}[z]/T*⁴ > 0` (estritamente, salvo p degenerada) —
+mínimo local estrito. ∎
+
+**Validação numérica**: teste `n1` — L' e L'' analíticos vs diferenças finitas
+centrais (h = 10⁻², escolhido no equilíbrio ruído-f32/truncamento): acordam em
+< 5·10⁻³ e < 5·10⁻² respectivamente; e a REGRESSÃO DA ERRATA: logits
+superconfiantes ⇒ `L'(1) < 0` (a proposta original daria > 0).
+
+### 2.3 Teo N-2 (convexidade em γ = 1/T — fortalece a V-1) ∎
+
+Seja `L̃(γ) = (1/n)·Σᵢ [−γ·z_{i,yᵢ} + log Σⱼ exp(γ·z_{i,j})]`. Então:
+
+1. `L̃''(γ) = médiaᵢ Var_{pᵢ(γ)}(zᵢ) ≥ 0` para **todo** γ > 0 — L̃ é convexa;
+2. `L(T) = L̃(1/T)` e T ↦ 1/T é bijeção decrescente de (0,∞) ⇒ **L é unimodal
+   em T** com mínimo único em `T* = 1/γ*`;
+3. `L̃'(γ) = médiaᵢ (E_{pᵢ}[zᵢ] − z_{i,yᵢ})` troca o sinal exatamente uma vez.
+
+**Prova.** (1): `dp_j/dγ = p_j(z_j − E_p[z])` (derivada do softmax na escala
+γ), logo `d/dγ E_p[z] = E_p[z²] − E_p[z]² = Var_p[z] ≥ 0`; a média preserva a
+desigualdade. (2): composição de convexa com afim-decrescente em T dá
+decrescente- depois crescente- em T (para T < T* γ > γ* e L̃ crescente à
+direita de γ*, etc.). (3): segue de (1)+(2). ∎
+
+**Consequências**: (a) a "unimodalidade empírica" que a v0.6.0 verificava por
+teste (v3) agora é **teorema** — o golden-section da V-1 está justificado
+retrospectivamente; (b) a bisseção sobre o sinal de L̃' é válida; (c) o teste
+`n3` (varredura de 64 pontos em T log-espaçados: exatamente 1 troca de sinal)
+valida (3) empiricamente.
+
+*Nota estatística (n4b)*: a contribuição de cada amostra para `L̃'(γ)` é
+`Σ_{j≠y} p_j(z_j − z_y)` — ≤ 0 para acertos (z_y = argmax) e ≫ 0 para **erros
+confiantes**. É por isso que a NLL "escuta" os erros: superconfiança genuína
+(exige T* > 1) só ocorre com erros confiantes — o padrão de overfitting. O
+teste n4b reconstrói os dois regimes sinteticamente (95% acertos com margem
+5,4 + 5% erros com margem 8,4 ⇒ T* > 1; margem 3 com ruído ≈ 0 ⇒ T* = 1/8).
+
+### 2.4 Teo N-3 (convergência do Newton com salvaguarda) ∎
+
+O `calibrar_temperatura_newton` itera em **γ** (não em T): a cada passo avalia
+`(L, L̃', L̃''=Var)` em γ; mantém o colchão `[a,b] ⊆ [1/8, 8]` com o invariante
+`L̃'(a) < 0 < L̃'(b)`; o passo de Newton `γ ← γ − L̃'/L̃''` é **aceito apenas
+se cai estritamente dentro de (a,b)** — caso contrário, bisseção geométrica
+`γ ← √(ab)` (o análogo log-T da V-1). Então:
+
+1. **Global**: o colchão contém γ* em todo momento (invariante + N-2.3); cada
+   bisseção divide `ln(b/a)` por 2 ⇒ ≤ ⌈log₂(ln 64/ε)⌉ ≈ 35 passos no pior
+   caso; termina em |L̃'| < 10⁻¹⁰ ou orçamento.
+2. **Local (quadrática)**: perto de γ*, `L̃''(γ*) = Var* > 0` e L̃ ∈ C² ⇒ o
+   erro satisfaz `|e_{k+1}| ≤ (M/2m)|e_k|²` com `M = sup|L̃'''|`, `m = inf L̃''`
+   (Newton–Kantorovich; Ortega & Rheinboldt, §10.2).
+3. **Em γ nunca há curvatura negativa** (L̃'' = Var ≥ 0 sempre — N-2.1), ao
+   contrário de em T, onde L'' pode ser negativa longe do ótimo — por isso a
+   iteração foi formulada em γ.
+
+∎
+
+### 2.5 Medição (demo_qwen_v080, n=1024, K=32, superconfiante)
+
+| Método | avaliações | tempo | T* | NLL(T*) |
+|--------|-----------|-------|-----|---------|
+| golden-section (V-1, mantido) | ~44 (64 máx) | 8,30 ms | 0,34412 | 0,69928968 |
+| **Newton γ (N-4, novo)** | **14** | 5,47 ms | 0,34408 | 0,69928992 |
+
+T* concorda em 3,7·10⁻⁵; NLL difere em 2,4·10⁻⁷ (nível do ε da f32 — ambos
+dentro do ruído do mínimo); **3,1× menos avaliações, 1,5× menos tempo**
+(cada avaliação Newton custa ~2 NLLs pois computa CE + momentos, mas o total
+vence). O `VerificadorNcm::ajustar` agora usa Newton com o golden-section
+como **rede de segurança explícita** (nunca removido): se o Newton falhasse
+(NLL pior que a bruta + 10⁻⁶ — nunca observado), recai na V-1.
+
+---
+
+## §3 — Proposta 2: iteração segura em árvores (arvore_pesos.rs)
+
+### 3.1 Análise da proposta
+
+A proposta (pós-ordem com pilha explícita, flags `visitados`, processamento em
+duas fases) está **essencialmente correta** para árvores estritas — é o
+algoritmo clássico de travessia pós-ordem iterativa. Três lacunas:
+
+1. **Filhos duplicados no mesmo pai escapam** da checagem por estado: quando o
+   pai lista o filho X duas vezes, o 2º push ocorre ANTES da expansão do 1º
+   (a marcação por estado só é verificada na expansão) ⇒ X entra DUAS vezes na
+   pós-ordem ⇒ soma dupla silenciosa. **Correção adotada**: flag `empilhado`
+   marcado **no momento do push** — re-empilhamento é recusado com erro
+   explícito (a recursiva da v0.6.0 somaria duas vezes sem sinalizar).
+2. **Sem detecção de ciclos**: um ciclo A↔B termina (não laça infinito), mas
+   produz ordem inválida e agregado sem sentido. Com a correção (1), a
+   re-entrada de ciclo também é recusada no push; adicionalmente o
+   `invariantes_ok` ganhou **(iv) simetria pai↔filho** e **(v) alcançabilidade
+   BFS da raiz** (Teo T-A9 abaixo) — que capturam ciclos que as checagens
+   (i)–(iii) da v0.6.0 deixavam passar (ex.: 2-ciclo desconectado x↔y).
+3. O comentário "processamento na ordem inversa" estava errado — a pós-ordem
+   JÁ é folhas-primeiro; a iteração é direta.
+
+### 3.2 Teo T-A7 (equivalência bit-a-bit com a recursiva) ∎
+
+**Lema (ordem)**: a pós-ordem produzida pela pilha com empilhamento reverso
+dos filhos coincide com a ordem de retorno da recursão `agregar_rec`.
+*Prova por indução na altura h*: h = 0 (folha): empilha, reencontra com
+estado 1, desempilha — única na saída; a recursão retorna imediatamente. Passo:
+para um nó com filhos f₁…f_m (empilhados em ordem reversa, processados na
+ordem original), os blocos de pós-ordem das subárvores completam na ordem
+f₁, …, f_m seguidos do próprio nó — exatamente a ordem de retorno da recursão.
+∎
+
+**Teorema**: com a mesma ordem de visitação e a mesma ordem de soma
+(`total = próprio + Σ_f v_f` na ordem f₁…f_m), a sequência de operações de
+ponto flutuante é idêntica ⇒ **resultados bit-a-bit idênticos** à v0.6.0
+(IEEE-754: mesma sequência de ops ⇒ mesmo resultado). Teste `ta7`: 8 árvores
+aleatórias (ramificação E profundidade), totais e vetores `credito` comparados
+por `to_bits()` — iguais em todas. ∎
+
+### 3.3 Teo T-A8 (custo e robustez) ∎
+
+Seja V = nós, E = arestas (|E| = V−1 em árvore). A iterativa: tempo O(V+E),
+espaço adicional O(V) (pilha + pós-ordem + 2 flags), **zero alocações por
+nó**. A recursiva v0.6.0: O(V+E) tempo, mas **1 clone de `Vec` por nó**
+(Θ(Σ|filhos|) alocações) e O(profundidade) quadros de pilha — na thread de
+teste (2 MiB) uma cadeia degenerada de ~10⁴–10⁵ nós excede a pilha. A iterativa
+processa **100.000 nós em cadeia** (teste ta7b) sem estourar; a soma global e
+o crédito por enlace estão corretos (T-A2 preservado). Medição (20.012 nós,
+thread principal): 3,63 ms vs 4,06 ms — ~11% mais rápida no caso cadeia (o
+ganho estrutural é a robustez e a eliminação de clones; em árvores rasas os
+tempos são equivalentes). ∎
+
+### 3.4 Teo T-A9 (as checagens (iv)+(v) caracterizam árvore) ∎
+
+Com (i) todo não-raiz tem pai listado e a raiz não tem; (iv) todo filho
+listado por u tem pai = u; (v) todo nó é alcançável da raiz por BFS seguindo
+`filhos`: o grafo direcionado é uma **árvore enraizada**. *Prova*: (i)+(iv) ⇒
+a relação pai→filho é consistente e cada nó tem ≤ 1 pai (se u lista f, o pai de
+f é u por (iv); se u' ≠ u também listasse f, o pai de f seria u' ≠ u —
+contradição com "≤ 1"). Se houvesse ciclo, os nós do ciclo teriam pais no
+ciclo; um nó do ciclo alcançável da raiz receberia uma aresta externa do
+caminho da raiz ALÉM da aresta do ciclo — 2 pais, contradição; ciclo
+desconectado viola (v). Logo acíclico + conectado + raiz única = árvore. ∎
+Teste `ta8`: duplicata ⇒ NaN (recusa); assimetria ⇒ erro (iv); 2-ciclo
+desconectado ⇒ erro (v).
+
+### 3.5 Adições conexas
+
+`anexar_filho(pai, nome, n_params)` — API pública para anexar subárvores com
+aresta dupla mantendo o índice de adjacência e a partição (1 entrada de
+`credito`/`regulacao` **por enlace** — 2 por aresta; ver errata minha no §6);
+`regular_topo_fundo` também iterativa (pré-ordem, mesma semântica λ^k do PAI —
+teste ta7c); `agregar_fundo_topo_rec` mantida como oráculo de referência.
+
+---
+
+## §4 — Proposta 3: exatidão algébrica em rotações — Cayley (fnh.rs)
+
+### 4.1 Errata da proposta original
+
+1. **`den.inv()` não existe em candle 0.11** (verificado no fonte do crate) —
+   a proposta assumia uma API inexistente; o próprio comentário admitia
+   "Assumindo implementação de inversão ou solve". Além disso, uma inversão
+   por LU/pivoteamento **não é expressável em ops de tensor fixas** e romperia
+   o autograd.
+2. **Convenção de sinal**: `(I − A/2)(I + A/2)⁻¹ = expm(−A + O(A³))` — a
+   identidade escalar `(1−t)/(1+t) = e^{−2·artanh(t)}` eleva-se a matrizes
+   comutantes (funções de A). A proposta, portanto, constrói a rotação
+   **contrária** à série de Taylor do gru-ring (`expm(+A)`). Para o FNH isso é
+   indiferente (a família {Cayley(A) : A skew} é a mesma de θ ↦ −θ), mas a
+   paridade semântica com o port exige `(I + A/2)(I − A/2)⁻¹`.
+   **Verificação independente**: oráculo NumPy (SVD para o fator polar do
+   truncado; `expm` por série longa) — com θ ∈ [0,05, 0,32], n = 8:
+   `‖polar(trunc) − expm(A)‖ = 0,047` mas `‖(I−A/2)(I+A/2)⁻¹ − expm(A)‖ = 2,51`
+   (≈ 2‖A‖ — espelho); com a convenção corrigida a distância cai para o
+   esperado O(‖A‖³/12).
+
+### 4.2 Teo F-9 (Cayley ∈ SO(n), invertibilidade e condicionamento) ∎
+
+Com A skew-simétrica n×n e B = A/2:
+
+1. **(i) I−B é invertível**: se `(I−B)v = 0` então `v = Bv` e
+   `vᵀv = vᵀBv = 0` (vᵀBv = −vᵀBᵀv = −vᵀBv ⇒ = 0 para B skew) ⇒ v = 0. ∎
+2. **(ii) RᵀR = I** para `R = (I+B)(I−B)⁻¹`: `Rᵀ = (I−B)⁻ᵀ(I+B)ᵀ =
+   (I+B)⁻¹(I−B)` (transposta de inversa; (I±B)ᵀ = I∓B). Como I+B e I−B são
+   polinômios em B, **comutam**: `(I+B)(I−B) = I−B² = (I−B)(I+B)`. Logo
+   `RᵀR = (I+B)⁻¹(I−B)(I+B)(I−B)⁻¹ = I`. ∎
+3. **(iii) det R = +1**: `det(I−B) = det((I+B)ᵀ) = det(I+B)` ⇒ razão 1. ∎
+4. **(iv) condicionamento**: eig(B) = ±iλ_k/2 ⇒ eig(I−B) = 1∓iλ_k/2,
+   |eig| = √(1+λ_k²/4) ≥ 1; I−B é normal (B skew) ⇒ valores singulares =
+   |eig| ⇒ `κ(I−B) = √(1+‖A‖₂²/4) ≤ √(1+clamp²·n(n−1)/16)` — bem
+   condicionado **para todo θ no clamp**, sem pivoteamento. ∎
+5. **Bijução**: Cayley mapea skew(n) sobre {R ∈ SO(n) : −1 ∉ eig(R)} com
+   inversa `A = 2(I−R)(I+R)⁻¹`; rotações com ângulo exatamente π são
+   inatingíveis — conjunto de medida zero, irrelevante ao treino por
+   gradiente (limitação honesta herdada da proposta).
+
+### 4.3 Teo F-10 (inversão por Newton, diferenciável e com convergência provada) ∎
+
+A inversa de M = I−B é computada pela iteração `X ← X(2I − MX)` com
+`X₀ = αMᵀ`, `α = 1/(1+‖B‖²_F)`:
+
+1. O erro `E_k = I − MX_k` satisfaz `E_{k+1} = E_k²` (verificação direta:
+   `I − MX(2I−MX) = (I−MX)²`) ⇒ convergência **quadrática espectral** quando
+   ‖E₀‖₂ < 1.
+2. `MMᵀ = (I−B)(I+B) = I−B²`; B² é simétrica negativa-semidefinida
+   (B² = −BᵀB), eig(B²) ∈ [−‖B‖₂², 0]; então
+   `E₀ = I − α(I−B²) = (1−α)I + αB²` tem autovalores em
+   `[1−α(1+‖B‖₂²), 1−α] ⊆ [0, ‖B‖²_F/(1+‖B‖²_F)] ⊂ [0,1)` (usa
+   ‖B‖₂² ≤ ‖B‖²_F) ⇒ ‖E₀‖₂ < 1 **sempre** — a iteração nunca diverge. ∎
+3. Custo: 2 matmuls por iteração + teste de resíduo (saída antecipada
+   ‖I−MX‖∞ < 10⁻⁷). No pior caso do clamp (todos θ = 0,5, n = 16:
+   ‖B‖²_F = 15, ρ = 15/16): ρ^{2^k} < 10⁻⁷ ⇒ k = 8 — teto 12 com margem.
+4. **Nascimento neutro**: θ = 0 ⇒ B = 0 ⇒ α = 1 EXATO ⇒ X₀ = Mᵀ = I e o
+   resíduo |1−α| = 0 encerra na 1ª iteração ⇒ R = I **bit-a-bit com o grafo
+   conectado a θ** (gradiente flui no nascimento — teste f9; o caminho polar
+   precisa de atalho especial para o mesmo efeito).
+5. **Diferenciabilidade**: todas as ops (affine, matmul, sub) são rastreadas
+   pelo autograd do candle — o gradiente flui através da inversa (não há
+   detach). Teste f10: pior caso do clamp confere com Gauss–Jordan f64
+   (máx |Δ| < 10⁻³) e δ_ort ≤ 10⁻⁶.
+
+### 4.4 Teo F-11 (blocos 2×2 em fórmula fechada) ∎
+
+Para rotação restrita a planos canônicos (bloco-diagonal com blocos
+`S_k = [[0,−s_k],[s_k,0]]`, s_k = θ_k/2), a inversão de `I−S_k` é analítica:
+`(I+S_k)(I−S_k)⁻¹ = [[1−s², −2s],[2s, 1−s²]]/(1+s²)` (produto direto das
+matrizes 2×2; ortogonal por F-9.ii; ângulo α_k com tan(α_k/2) = s_k —
+fórmula do semi-ângulo). A montagem usa 1 matmul com matriz de seleção
+constante (2m, n²) — **sem inversão, sem iteração**, O(n²) entradas
+escritas, zero EXATO fora dos blocos (0·x em f32), nascimento neutro bit-a-bit
+e grafo vivo (teste f11). Família RESTRITA (n/2 graus de liberdade, sem
+mistura entre planos) — indicada quando n é grande e o custo O(n³) das
+rotações completas domina. ∎
+
+### 4.5 Teo F-12 (paridade polar ↔ Cayley) ∎
+
+`polar(I + A + A²/2 + A³/6) = expm(A + O(‖A‖⁵))` (o erro de truncamento
+O(A⁴) é **simétrico** — A⁴ é simétrico para A skew — e o fator polar é
+insensível a 1ª ordem à parte simétrica), enquanto
+`Cayley(A) = expm(2·artanh(A/2)) = expm(A − A³/12 + O(A⁵))`. Logo
+`‖R_polar − R_cayley‖_F = O(‖A‖³/12)`. Teste f12 (θ ∈ [0,02, 0,155], n = 8):
+distância 10⁻³–10⁻², razão desvio/distância-à-identidade < 0,25. Ambos os
+modos coexistem (`ModoRotacao::Polar` padrão — compatibilidade v0.7.0 bit-a-bit;
+`Cayley` opt-in). ∎
+
+### 4.6 Medição (n = 16, θ espalhado no clamp, média de 25 rotações)
+
+| Modo | tempo/rotação | δ_ort |
+|------|--------------|-------|
+| polar (40 Newton–Schulz + série) | 1,89 ms | 3,0·10⁻⁷ |
+| **Cayley (Newton-inverso adaptativo)** | **0,46 ms** | 8,9·10⁻⁷ |
+
+**4,1× mais rápido** com exatidão equivalente (ambos < 10⁻⁶). O ganho cresce
+com n (o polar paga 40 iterações fixas; o Cayley sai cedo perto do nascimento —
+1–3 iterações típicas).
+
+---
+
+## §5 — Proposta 4: roteamento e perda auxiliar em ops de tensor (moe_redirecionavel.rs)
+
+### 5.1 Análise da proposta
+
+O esboço terminava em `unimplemented!("Kernel customizado de Scatter/Gather
+necessário")` — não era código executável. A fórmula da perda auxiliar
+`E·Σ_e f_e·p̄_e` está **correta** (Switch Transformer, Fedus et al. 2022 — e
+já era a da casa, M-R1). A substância (manter roteamento/acúmulo/perda em
+operações de tensor, sem round-trips por especialista) é válida e — como o
+ambiente é CPU — reinterpretada como "ops de tensor rastreadas", não "GPU".
+
+### 5.2 Teo M-R6 (equivalência de valores) ∎
+
+`fwd_vetorizado` compartilha com `fwd` o **mesmo auxiliar de seleção**
+(`selecionar_com_capacidade`, extraído verbatim da v0.6.0: mesma ordem de
+candidatos, mesmos desempates estáveis de `sort_by`) ⇒ mesmos tokens aos
+mesmos especialistas, mesma carga, mesmos descartados. O acúmulo usa
+`index_add` na **mesma ordem** de inserção que o loop Rust da v0.6.0 ⇒
+somas na mesma sequência ⇒ **valores bit-a-bit idênticos** (medido:
+max|Δsaída| = 0,0). A perda auxiliar: mesma fórmula com `p̄` do tensor vivo. ∎
+
+### 5.3 Teo M-R7 (o bug v080-1 e sua correção) ∎
+
+**O bug**: na `fwd` v0.6.0, a contribuição de cada especialista era
+materializada por `to_vec2::<f32>()` e recriada com `Tensor::from_vec` —
+operação que **cria um novo tensor folha, desconectado do grafo** (o
+`from_vec` não carrega histórico de autograd). Idem os pesos `w` e a perda
+auxiliar (constituída de `from_vec` de valores lidos). Consequência: na
+passada MoE, `∂perda/∂(pesos dos especialistas) = 0` e
+`∂perda/∂(pesos do roteador) = 0` — **apenas a atenção própria treinava** no
+braço MoE (o resíduo `y + roteamento` só conecta `y`).
+
+**Prova do bug (medida)**: com `perda = ‖saida‖²`, os gradientes do roteador e
+dos especialistas são **exatamente 0,0** na `fwd` (normas 0/0) e **> 0** na
+`fwd_vetorizada` (1,36·10⁵ / 2,30·10⁶ na medição) — teste mr7.
+
+**A correção**: (a) `saida = saida.index_add(&idx, &contrib, 0)` — `IndexAdd`
+é uma op **rastreada** pelo autograd do candle (enum `BackpropOp::IndexAdd`,
+fonte do crate); (b) os pesos `w` são fatiados do PRÓPRIO tensor `probs`
+(`index_select` das linhas + `narrow` da coluna) — gradiente flui ao roteador;
+(c) a perda auxiliar usa `p̄ = probs_local.mean_keepdim(0)` do tensor vivo,
+com `f` constante (padrão Switch: argmax não é diferenciável, a média das
+probabilidades carrega o gradiente). ∎
+
+**Corolário (leitura honesta da v0.6.0)**: o resultado publicado em r-27
+"JEPA 3 braços: pequena 0,129 > densa 0,107 > moe 0,059 — roteamento ganha
+45% da capacidade equiparada" estava **confundido**: no braço MoE só a atenção
+própria treinava; o número refletia atenção+resíduo, não o roteamento. A
+re-ablação com o gradiente restaurado (abaixo) é a leitura correta.
+
+**M-R8 (fim-a-fim)**: 5 passos de AdamW pela `fwd_vetorizado` mudam os pesos
+dos especialistas (δ > 0) — regressão permanente do bug.
+
+### 5.4 Re-ablação JEPA 3 braços (gradiente restaurado; 120 passos, lote 64×12, máscara 50%)
+
+A inicialização usa o RNG global do candle (não semeado pela API atual) — os
+números variam entre execuções; gates direcionais (moe ≫ pequena em quedas)
+observados em TODAS as execuções. Execução típica:
+
+| Braço | perda inicial | perda final | queda |
+|-------|--------------|-------------|-------|
+| pequena (2·d) | 1,000 | 0,765 | −23,5% |
+| densa (capacidade equiparada 2·d·e) | 1,062 | 0,984 | −7,4% |
+| **moe (4+4 especialistas, top-2)** | 0,660 | **0,075** | **−88,7%** |
+
+Leitura honesta: (a) o MoE agora treina especialistas+roteador+atenção e a
+queda é dramática; (b) a densa **quase não aprende** (e em algumas execuções
+piora) — com lr 3e-3 fixo e 120 passos, a rede densa grande é instável neste
+orçamento; isso NÃO é evidência de superioridade estrutural permanente do
+MoE, e sim de que o roteamento + capacidade particionada treina melhor neste
+regime — a afirmação forte requer o pareamento wall-clock/capacidade
+(débito herdado V15, mantido); (c) a inicialização do braço moe já parte de
+perda menor (0,66 vs 1,0) porque a saída residual `y + roteamento` com pesos
+~1/e_local reduz a escala inicial — comparação de QUEDA relativa, não de
+nível absoluto.
+
+### 5.5 Medição de custo
+
+| Versão | tempo/passada (n=256, d=32, E=8) |
+|--------|----------------------------------|
+| fwd (referência, round-trips) | 1,93 ms |
+| **fwd_vetorizada (index_add)** | **1,58 ms** |
+
+1,22× mais rápida (o gargalo remanescente é a seleção discreta em Rust —
+O(E·n·log n) — compartilhada por ambas; a proposta de substituí-la por
+top-k em tensor fica como extensão: exigiria `scatter_add` com semântica de
+capacidade não disponível em candle 0.11 sem kernel customizado).
+
+---
+
+## §6 — Bugs catalogados nesta iteração (causa-raiz, tradição r-07/r-27)
+
+| ID | Onde | Causa-raiz | Correção |
+|----|------|-----------|----------|
+| v080-1 | moe `fwd` v0.6.0 | `to_vec2`/`from_vec` seccionam o grafo de autograd — especialistas/roteador sem gradiente (exposto pela proposta Qwen nº 4) | `fwd_vetorizado` com `index_add` rastreada; treinos migrados; `fwd` mantida como referência documentada |
+| v080-2 | quantizador `gsq_suave` v0.6.0 (pré-existente) | `debug_assert_eq!(ruido.len(), z.len()/d*k*d/d*k)` — expressão sem sentido (320 ≠ 40) que dispara em TODO build debug; os gates v0.7.0 só passavam em release (assert compilado fora) | fórmula correta `n*k`; testes agora verdes em debug E release |
+| v080-3 (meu) | fnh `rotacao_cayley` (1ª versão) | `mx.affine(-1.0, 2.0)` soma 2 a TODAS as entradas (2·J − MX) em vez de só à diagonal — iteração diverge (NaN) | `ident.affine(2.0,0.0)?.sub(&mx)` = 2I − MX |
+| v080-4 (meu) | arvore `anexar_filho` (1ª versão) | 1 push em `credito`/`regulacao` por aresta, mas são indexadas por ENLACE (2 por aresta dupla) — out-of-bounds | 2 pushes (1 por enlace) |
+| v080-5 (meu) | teste mr8 (1ª versão) | snapshot via `.detach()` **compartilha o storage** com a Var — o `set()` do otimizador sobrescreve a "cópia" ⇒ delta ≡ 0 (falso negativo) | snapshot por `to_vec1` (dados próprios) |
+
+O v080-3/4/5 foram capturados pelos próprios testes novos antes de qualquer
+publicação — o processo analisar→provar→testar funcionou como projetado.
+
+---
+
+## §7 — Resultados consolidados (cargo 99/99, 3× determinismo; ver §2–§5)
+
+1. **Newton (verificador)**: 14 vs ~44 avaliações (3,1×), 1,5× tempo, T*
+   concorda 3,7·10⁻⁵; golden-section mantido como rede de segurança;
+   unimodalidade promovida de empírica a teorema (N-2).
+2. **Árvore iterativa**: bit-a-bit idêntica (T-A7), 100k nós sem estourar
+   pilha (T-A7b), ~11% mais rápida em cadeia de 20k; detecção de
+   duplicatas/ciclos (T-A8/T-A9) que a v0.6.0 não tinha.
+3. **Cayley (FNH)**: 4,1× mais rápido que polar, δ_ort ≤ 8,9·10⁻⁷, det = +1,
+   nascimento neutro com grafo vivo, convergência da inversão PROVADA (F-10);
+   2 erratas na proposta (inv() inexistente; sinal expm).
+4. **MoE vetorizada**: valores bit-a-bit idênticos, 1,22× mais rápida,
+   gradiente restaurado (bug v080-1), re-ablação honesta com MoE −88,7%.
+5. **Regressão**: 84 testes herdados verdes (incluindo os 2 do quantizador
+   agora também em debug — v080-2) + 15 novos (n1–n4b, ta7/ta7b/ta7c/ta8,
+   f9–f12, mr6/mr7/mr8) = **99/99**; 3 execuções consecutivas idênticas.
+
+## §8 — Débitos honestos remanescentes
+
+1. A ablação JEPA usa o RNG global do candle na inicialização (não semeado) —
+   os gates são direcionais; a semeadura determinística da inicialização é
+   extensão desejável (expor `candle` seed ou inicializar via `RngDeterministico`).
+2. A seleção top-k com capacidade permanece em Rust O(E·n·log n) — vetorializá-
+   la exigiria kernel customizado (`scatter_add` com semântica de capacidade
+   não disponível em candle 0.11); o ganho marginal sobre o já-otimizado
+   acúmulo não justifica a complexidade agora.
+3. O pareamento wall-clock/capacidade entre braços (V15, herdado) segue
+   pendente — a nova ablação não fecha essa conta.
+4. `nll_newton` supera `nll_golden` em 2,4·10⁻⁷ (nível ε-f32): ambos estão
+   dentro do ruído do mínimo; um passo de polimento golden pós-Newton
+   eliminaria a diferença cosmética se algum gate futuro exigir.
+5. Cayley não representa rotações de ângulo exatamente π (medida zero) —
+   irrelevante ao treino, registrado por completude.

resultados/suite_v080_final.json

@@ -0,0 +1,149 @@
+{
+ "versao": "0.8.0",
+ "blocos": {
+  "legado_v070": "73/73",
+  "q1_newton": "3/3",
+  "q3_cayley": "2/2",
+  "q2_arvore": "1/1",
+  "q4_moe": "3/3",
+  "q5_ablacao": "2/2",
+  "cargo": "97/97"
+ },
+ "gates": {
+  "legado_legado_calibracao_soundness.v1_calibracao": true,
+  "legado_legado_calibracao_soundness.v2_soundness": true,
+  "legado_legado_calibracao_soundness.v3_tau_positivo": true,
+  "legado_legado_ciclo_d_sem_oraculo.aprendeu": true,
+  "legado_legado_ciclo_d_sem_oraculo.terminou": true,
+  "legado_legado_ciclo_d_sem_oraculo.sem_oraculo": true,
+  "legado_legado_ciclo_d_sem_oraculo.calibrado": true,
+  "legado_legado_ciclo_d_sem_oraculo.ganho_nao_negativo": true,
+  "legado_legado_ciclo_d_sem_oraculo.verificador_sem_oraculo": true,
+  "legado_legado_escalonamento_n.tp2_ncm": true,
+  "legado_legado_fase_c.verificador_sem_oraculo": true,
+  "legado_legado_fase_c.calibracao_nll_otima": true,
+  "legado_legado_fase_c.ece_aceitavel_para_soundness": true,
+  "legado_legado_fase_c.correcao_ativa": true,
+  "legado_legado_fase_c.acoplador_sem_timeout": true,
+  "legado_legado_fase_c.acoplador_duplex_ativo": true,
+  "legado_legado_fase_c.confianca_pos_nao_inferior": true,
+  "legado_legado_fase_c.backbone_preservado": true,
+  "legado_legado_fase_c.pcgrad_sem_conflito_observado": true,
+  "legado_legado_provas_mr.mr1_capacidade": true,
+  "legado_legado_provas_mr.mr1_perda_aux": true,
+  "legado_legado_provas_mr.mr2_neutralidade": true,
+  "legado_legado_provas_mr.mr3_paralelismo": true,
+  "legado_legado_provas_mr.mr5_water_filling": true,
+  "legado_legado_jepa_moe.jepa_moe_aprende": true,
+  "legado_legado_jepa_moe.jepa_moe_vs_densa": true,
+  "legado_legado_jepa_moe.jepa_moe_vs_pequena": true,
+  "legado_legado_som_moe.moe_refina": true,
+  "legado_legado_som_moe.redirect_decodifica": true,
+  "legado_legado_som_moe.wf_melhor_uniforme": true,
+  "legado_legado_acoplador_duplo.duplex_simultaneo": true,
+  "legado_legado_acoplador_duplo.sem_timeout": true,
+  "legado_legado_acoplador_duplo.terminou": true,
+  "legado_legado_iter.gate_ucb1_encontrou_moe": true,
+  "legado_legado_iter.gate_gap_positivo_vs_baseline": true,
+  "legado_legado_iter.gate_arrependimento_pequeno": true,
+  "legado_legado_iter.gate_regulacao_ocorreu": true,
+  "legado_legado_iter.gate_parada_ou_teto": true,
+  "legado_legado_iter.gate_melhor_aprendeu": true,
+  "legado_legado_iter.a1_tau_quantil": true,
+  "legado_legado_iter.a2_b_finito": true,
+  "legado_legado_iter.a3_n_reduzido": true,
+  "legado_legado_iter.a4_ucb1_achou": true,
+  "legado_legado_iter.a5_gate_subiu": true,
+  "legado_legado_legada_suite_v": true,
+  "legado_legado_cargo_54": true,
+  "legado_fnh_f1_so_n_exato": true,
+  "legado_fnh_f3_gate_zona_morta": true,
+  "legado_fnh_f3_gate_abre": true,
+  "legado_fnh_f4_homeostase_theta_congelado": true,
+  "legado_fnh_f4_rotacao_aprende_com_punicao": true,
+  "legado_fnh_a2_delta_ort_treino_real": true,
+  "legado_fnh_a3_punicao_real_medida": true,
+  "legado_arvore_quebra_t1_invariantes": true,
+  "legado_arvore_quebra_t2_agregacao_exata": true,
+  "legado_arvore_quebra_t3_teto_simetrico": true,
+  "legado_arvore_quebra_q1_executa_real": true,
+  "legado_arvore_quebra_q2_soundness_aceites": true,
+  "legado_arvore_quebra_q3_invariantes_pos_quebra": true,
+  "legado_arvore_quebra_q4_punicao_registrada": true,
+  "legado_arvore_quebra_q5_sintetico_mistura_aceita_rejeita": true,
+  "legado_nlp_nlg_n_coerencia_ok": true,
+  "legado_nlp_nlg_n_espec_ok": true,
+  "legado_nlp_nlg_n_gate_medio_ok": true,
+  "legado_nlp_nlg_n_nlg_neutro": true,
+  "legado_nlp_nlg_n_nlp_neutro": true,
+  "legado_nlp_nlg_n_ctx_real_bigramas_unicos": true,
+  "legado_nlp_nlg_s_piso_ok": true,
+  "legado_nlp_nlg_s_qe_sobe": true,
+  "legado_nlp_nlg_s_stop_dispara": true,
+  "legado_nlp_nlg_s_tetos_ok": true,
+  "legado_telemetria_painel_v070": true,
+  "legado_treino_real_completo": true,
+  "q1_newton_menos_avaliacoes": true,
+  "q1_newton_mesmo_t": true,
+  "q1_newton_nll_nao_piora": true,
+  "q3_cayley_ambos_exatos": true,
+  "q3_cayley_cayley_mais_rapido": true,
+  "q2_arvore_iguais_bit_a_bit": true,
+  "q4_moe_bug_v080_1_confirmado": true,
+  "q4_moe_gradiente_restaurado": true,
+  "q4_moe_valores_iguais": true,
+  "q5_ablacao_moe_aprende_3x": true,
+  "q5_ablacao_moe_domina_pequena_3x": true,
+  "cargo_todos_verdes": true
+ },
+ "medicoes": {
+  "q1": {
+   "t_golden": 0.3441249091032295,
+   "t_newton": 0.34408817449108714,
+   "n_aval_newton": 14,
+   "nll_golden": 0.6992896795272827,
+   "nll_newton": 0.6992899179458618,
+   "tempo_golden_s": 0.00854757,
+   "tempo_newton_s": 0.005394317
+  },
+  "q3": {
+   "delta_ort_polar": 2.2211075543847625e-07,
+   "delta_ort_cayley": 8.905649464341503e-07,
+   "tempo_polar_s": 0.0018697242799999999,
+   "tempo_cayley_s": 0.00045946215999999996,
+   "speedup": 4.069375985173622
+  },
+  "q2": {
+   "n_nos": 20012,
+   "total_iter": 1.0,
+   "tempo_iter_s": 0.00387545,
+   "tempo_rec_s": 0.004315812
+  },
+  "q4": {
+   "max_dif_valores": 0.0,
+   "tempo_ref_s": 0.0018790862,
+   "tempo_vet_s": 0.0015372232,
+   "grad_roteador_vet": 146917.96875,
+   "grad_especialistas_vet": 2082642.984375
+  },
+  "q5": {
+   "quedas_moe_pct": [
+    87.36906150833764,
+    87.36640644795425,
+    90.96589194658534
+   ],
+   "quedas_pequena_pct": [
+    34.354170840846855,
+    32.05262864676725,
+    50.874721884012516
+   ],
+   "quedas_densa_pct": [
+    -15.90896709522771,
+    -5.185563598999177,
+    -9.804683063936093
+   ],
+   "nota": "inicialização via RNG global do candle — gates direcionais"
+  }
+ },
+ "veredito": "85/85"
+}

scripts/68_suite_v080.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""68_suite_v080.py — v0.8.0: VEREDITO CONSOLIDADO das propostas Qwen3.8.
+
+Executa demo_qwen_v080 TRÊS vezes (a ablação JEPA usa o RNG global do candle
+na inicialização — gates direcionais agregados sobre execuções), herda os 73
+gates da v0.7.0 (suite_v070_final.json) e adiciona os gates das 4 propostas
+analisadas/provadas/testadas em r-33:
+  1. Newton analítico (verificador) — N-1..N-4
+  2. Árvore pós-ordem iterativa — T-A7..T-A9
+  3. Cayley exato (FNH) — F-9..F-12
+  4. MoE vetorizada com gradiente restaurado (bug v080-1) — M-R6..M-R8
+"""
+import json, os, sys
+
+def main():
+    pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    R = os.path.join(pasta, "resultados")
+    rel = {"versao": "0.8.0", "blocos": {}, "gates": {}}
+
+    def carrega(arq):
+        p = os.path.join(R, arq)
+        if os.path.exists(p):
+            with open(p) as f:
+                return json.load(f)
+        return None
+
+    # ---- bloco legado v0.7.0 (se presente)
+    legado = carrega("suite_v070_final.json")
+    if legado:
+        g_legado = legado.get("gates", legado)
+        ok = sum(1 for v in g_legado.values() if v is True)
+        rel["blocos"]["legado_v070"] = f"{ok}/{len(g_legado)}"
+        for k, v in g_legado.items():
+            rel["gates"][f"legado_{k}"] = v
+
+    # ---- demos v0.8.0 (3 execuções)
+    import khtst_rust as k
+    execucoes = [k.demo_qwen_v080() for _ in range(3)]
+
+    # (1) Newton vs golden
+    nvg = execucoes[0]["newton_vs_golden"]
+    for nome, val in nvg["gates"].items():
+        rel["gates"][f"q1_newton_{nome}"] = val
+    rel["blocos"]["q1_newton"] = f"{sum(1 for v in nvg['gates'].values() if v)}/{len(nvg['gates'])}"
+    rel["medicoes"] = {
+        "q1": {kk: nvg[kk] for kk in
+               ("t_golden", "t_newton", "n_aval_newton", "nll_golden", "nll_newton",
+                "tempo_golden_s", "tempo_newton_s")},
+    }
+
+    # (2) Cayley vs polar
+    cvp = execucoes[0]["cayley_vs_polar"]
+    for nome, val in cvp["gates"].items():
+        rel["gates"][f"q3_cayley_{nome}"] = val
+    rel["blocos"]["q3_cayley"] = f"{sum(1 for v in cvp['gates'].values() if v)}/{len(cvp['gates'])}"
+    rel["medicoes"]["q3"] = {kk: cvp[kk] for kk in
+                             ("delta_ort_polar", "delta_ort_cayley",
+                              "tempo_polar_s", "tempo_cayley_s", "speedup")}
+
+    # (3) árvore iterativa
+    arv = execucoes[0]["arvore_iter_vs_rec"]
+    for nome, val in arv["gates"].items():
+        rel["gates"][f"q2_arvore_{nome}"] = val
+    rel["blocos"]["q2_arvore"] = f"{sum(1 for v in arv['gates'].values() if v)}/{len(arv['gates'])}"
+    rel["medicoes"]["q2"] = {kk: arv[kk] for kk in
+                             ("n_nos", "total_iter", "tempo_iter_s", "tempo_rec_s")}
+
+    # (4) MoE vetorizada (determinística — valores/gradientes)
+    moe = execucoes[0]["moe_vetorizada"]
+    for nome, val in moe["gates"].items():
+        rel["gates"][f"q4_moe_{nome}"] = val
+    rel["blocos"]["q4_moe"] = f"{sum(1 for v in moe['gates'].values() if v)}/{len(moe['gates'])}"
+    rel["medicoes"]["q4"] = {kk: moe[kk] for kk in
+                             ("max_dif_valores", "tempo_ref_s", "tempo_vet_s",
+                              "grad_roteador_vet", "grad_especialistas_vet")}
+
+    # (5) ablação JEPA 3 braços — gates DIRECIONAIS nas 3 execuções
+    quedas_moe, quedas_peq, quedas_den = [], [], []
+    for ex in execucoes:
+        ab = ex["ablacao_jepa_3_bracos_v080"]
+        quedas_moe.append(ab["moe"]["queda_pct"])
+        quedas_peq.append(ab["pequena"]["queda_pct"])
+        quedas_den.append(ab["densa"]["queda_pct"])
+    moe_min = min(quedas_moe)
+    peq_max = max(quedas_peq)
+    rel["gates"]["q5_ablacao_moe_aprende_3x"] = all(q > 30.0 for q in quedas_moe)
+    rel["gates"]["q5_ablacao_moe_domina_pequena_3x"] = moe_min > peq_max
+    rel["medicoes"]["q5"] = {
+        "quedas_moe_pct": quedas_moe, "quedas_pequena_pct": quedas_peq,
+        "quedas_densa_pct": quedas_den,
+        "nota": "inicialização via RNG global do candle — gates direcionais",
+    }
+    rel["blocos"]["q5_ablacao"] = (
+        f"{sum(1 for v in (rel['gates']['q5_ablacao_moe_aprende_3x'], rel['gates']['q5_ablacao_moe_domina_pequena_3x']) if v)}/2")
+
+    # ---- provas cargo (contagem)
+    try:
+        import subprocess, re
+        res = subprocess.run(
+            ["cargo", "test", "--manifest-path", os.path.join(pasta, "Cargo.toml")],
+            capture_output=True, text=True, timeout=1800,
+            env={**os.environ, "PATH": os.environ["PATH"] + ":" + os.path.expanduser("~/.cargo/bin")},
+        )
+        saida = res.stdout + res.stderr
+        linhas = [l for l in saida.splitlines() if "test result:" in l]
+        m = re.search(r"(\d+) passed; (\d+) failed", linhas[0] if linhas else "")
+        if m:
+            total_c = int(m.group(1)) + int(m.group(2))
+            rel["blocos"]["cargo"] = f"{m.group(1)}/{total_c}"
+            rel["gates"]["cargo_todos_verdes"] = m.group(2) == "0"
+        else:
+            rel["blocos"]["cargo"] = "sem resultado"
+            rel["gates"]["cargo_todos_verdes"] = False
+    except Exception as e:
+        rel["blocos"]["cargo"] = f"erro: {e}"
+        rel["gates"]["cargo_todos_verdes"] = False
+
+    # ---- veredito
+    total = len(rel["gates"])
+    ok = sum(1 for v in rel["gates"].values() if v is True)
+    rel["veredito"] = f"{ok}/{total}"
+    with open(os.path.join(R, "suite_v080_final.json"), "w") as f:
+        json.dump(rel, f, indent=1, ensure_ascii=False)
+    print(json.dumps({"blocos": rel["blocos"], "veredito": rel["veredito"]},
+                     indent=1, ensure_ascii=False))
+    sys.exit(0 if ok == total else 1)
+
+if __name__ == "__main__":
+    main()

scripts/69_publicar_v080.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""69_publicar_v080.py — Publicação da v0.8.0 no HF (UM ÚNICO upload_folder
+organizado — o HF bloqueia envios parciais em sequência e em curto espaço
+de tempo; uma única operação atômica evita o bloqueio).
+
+Fases:
+  1. inventário da conta + APAGAMENTO de estados de treino remanescentes;
+  2. varredura local do VALOR do token (nenhum arquivo pode contê-lo);
+  3. UM ÚNICO upload_folder com ignore_patterns EXPLÍCITOS (lição v0.7.0);
+  4. verificação pós-upload (0 estados, módulos-chave presentes, contagem);
+  5. varredura REMOTA do valor do token (baixa e inspeciona os arquivos).
+
+Token: EXCLUSIVAMENTE via variável de ambiente HF_TOKEN (nunca em arquivo).
+"""
+import os, sys, tempfile
+
+ARQUIVOS_EXCLUIR_DIRS = {"target", ".cargo", "__pycache__", ".git", ".venv",
+                         "skills", "externos"}
+ARQUIVOS_EXCLUIR_NOME = {"shard_treino.jsonl", "shard_validacao.jsonl",
+                         "bpe.json", "rustup-init.sh"}
+SUFIXOS_ESTADO = (".pt", ".pth", ".ckpt", ".safetensors", ".bin", ".npz",
+                  ".msgpack")
+NOMES_ESTADO = {"gerador_conceitos.json", "tokenizador_conceitos.json",
+                "gerador_aritmetica.json"}
+
+def coletar(pasta):
+    arquivos = {}
+    for raiz, dirs, fs in os.walk(pasta):
+        dirs[:] = [d for d in dirs if d not in ARQUIVOS_EXCLUIR_DIRS]
+        for f in fs:
+            if f in ARQUIVOS_EXCLUIR_NOME or f in NOMES_ESTADO:
+                continue
+            if f.endswith(SUFIXOS_ESTADO) or f.endswith(".estado.json"):
+                continue
+            if f.endswith(".so") or f in (".gitignore", "Cargo.lock.ori"):
+                continue
+            if f.startswith("hf_") or f.startswith("intros_"):
+                continue  # scripts de análise externa (não fazem parte)
+            caminho = os.path.join(raiz, f)
+            rel = os.path.relpath(caminho, pasta)
+            arquivos[rel] = caminho
+    return arquivos
+
+def varre_token_em_arquivos(token, pares):
+    tb = token.encode()
+    achados = []
+    for rel, p in pares.items():
+        try:
+            with open(p, "rb") as f:
+                if tb in f.read():
+                    achados.append(rel)
+        except OSError:
+            pass
+    return achados
+
+def main():
+    from huggingface_hub import HfApi
+    token = os.environ.get("HF_TOKEN")
+    if not token:
+        print("ERRO: HF_TOKEN ausente"); sys.exit(1)
+    api = HfApi(token=token)
+    repo = "PowerMachine/khtst-rust"
+
+    # ---------------- 1) inventário da conta + apaga estados ----------------
+    print("=== 1) inventário da conta HF (procura estados de treino) ===")
+    repos = list(api.list_models(author="PowerMachine"))
+    print(f"repos: {len(repos)}")
+    total_removidos = 0
+    for r in repos:
+        try:
+            files = api.list_repo_files(repo_id=r.id, repo_type="model")
+        except Exception as e:
+            print(f"  {r.id}: erro ao listar ({e})"); continue
+        estados = [f for f in files
+                   if f.endswith(SUFIXOS_ESTADO)
+                   or f.split("/")[-1] in NOMES_ESTADO
+                   or (".meta.json" in f and "checkpoint" in f)]
+        if estados:
+            print(f"  {r.id}: APAGANDO {len(estados)} estados")
+            for f in estados:
+                api.delete_file(path_in_repo=f, repo_id=r.id, repo_type="model")
+            total_removidos += len(estados)
+        else:
+            print(f"  {r.id}: {len(files)} arquivos, 0 estados")
+    print(f"estados removidos no total: {total_removidos}")
+
+    # ---------------- 2) varredura local do token ----------------
+    pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    arquivos = coletar(pasta)
+    print(f"\n=== 2) varredura local: {len(arquivos)} arquivos ===")
+    achados = varre_token_em_arquivos(token, arquivos)
+    if achados:
+        print(f"ERRO: valor do token encontrado em: {achados}"); sys.exit(1)
+    print("varredura de token local: limpa")
+    import subprocess
+    home = os.path.expanduser("~")
+    try:
+        saida = subprocess.run(
+            ["grep", "-rl", token, home, "--include=*.py", "--include=*.json",
+             "--include=*.md", "--include=*.sh", "--include=*.toml"],
+            capture_output=True, text=True, timeout=120)
+        if saida.stdout.strip():
+            print(f"ERRO: token no home: {saida.stdout.strip()}"); sys.exit(1)
+    except Exception:
+        pass
+    print("varredura do home: limpa")
+
+    # ---------------- 3) UM ÚNICO upload_folder ----------------
+    ignores = (
+        [f"{d}/**" for d in ARQUIVOS_EXCLUIR_DIRS]
+        + [f"{d}" for d in ARQUIVOS_EXCLUIR_DIRS]
+        + list(ARQUIVOS_EXCLUIR_NOME) + list(NOMES_ESTADO)
+        + list(SUFIXOS_ESTADO)
+        + ["*.so", ".gitignore", "hf_*.py", "hf_*.json", "intros_*.json",
+           "*.estado.json"]
+    )
+    print(f"\n=== 3) upload_folder ÚNICO ({len(arquivos)} arquivos) ===")
+    api.upload_folder(
+        repo_id=repo, repo_type="model", folder_path=pasta,
+        ignore_patterns=ignores, commit_message="v0.8.0: análise/prova/teste "
+        "das 4 propostas Qwen3.8 (r-33) — Newton analítico no verificador "
+        "(convexidade em gamma=1/T), árvore pós-ordem iterativa bit-a-bit "
+        "com detecção de ciclos, Cayley exato no FNH (4,1× mais rápido), "
+        "MoE vetorizada com gradiente RESTAURADO (bug v080-1) — 85/85 gates, "
+        "99/99 cargo",
+    )
+    print("upload concluído")
+
+    # ---------------- 4) verificação pós-upload ----------------
+    print("\n=== 4) verificação pós-upload ===")
+    files = api.list_repo_files(repo_id=repo, repo_type="model")
+    estados = [f for f in files if f.endswith(SUFIXOS_ESTADO)
+               or f.split("/")[-1] in NOMES_ESTADO]
+    assert not estados, f"estados publicados: {estados}"
+    chaves = ["src/verificador.rs", "src/arvore_pesos.rs", "src/fnh.rs",
+              "src/moe_redirecionavel.rs", "scripts/68_suite_v080.py",
+              "scripts/69_publicar_v080.py",
+              "docs/memorias/r-33-analise-provas-qwen-v080.md",
+              "resultados/suite_v080_final.json"]
+    faltando = [c for c in chaves if c not in files]
+    assert not faltando, f"faltando: {faltando}"
+    print(f"repo: {len(files)} arquivos | 0 estados | módulos-chave OK")
+
+    # ---------------- 5) varredura REMOTA do token ----------------
+    print("\n=== 5) varredura REMOTA do valor do token ===")
+    with tempfile.TemporaryDirectory() as tmp:
+        achados_remotos = []
+        for f in files:
+            if f.endswith((".py", ".rs", ".md", ".json", ".toml", ".sh", ".cfg",
+                           ".txt", ".jsonl")):
+                try:
+                    p = api.hf_hub_download(repo_id=repo, repo_type="model",
+                                            filename=f, local_dir=tmp)
+                    with open(p, "rb") as fh:
+                        if token.encode() in fh.read():
+                            achados_remotos.append(f)
+                except Exception:
+                    pass
+        if achados_remotos:
+            print(f"ERRO: token remoto em: {achados_remotos}"); sys.exit(1)
+    print("varredura remota: limpa")
+    print("\nPUBLICAÇÃO v0.8.0 CONCLUÍDA")
+
+if __name__ == "__main__":
+    main()

src/arvore_pesos.rs

@@ -176,10 +176,122 @@ impl ArvorePesos {
         caminho
     }
 
+    /// Anexa um filho com ARESTA DUPLA ao nó `pai` (nome, n_params) —
+    /// mantém o índice de adjacência e a partição do índice global (o
+    /// intervalo do novo nó continua o índice). Devolve o índice do novo nó.
+    /// v0.8.0: habilita subárvores profundas (teste T-A7b) sem reconstruir
+    /// a árvore — a pós-ordem iterativa não depende da profundidade.
+    pub fn anexar_filho(&mut self, pai: usize, nome: &str, n_params: usize) -> usize {
+        let idx = self.nos.len();
+        let prof = self.nos[pai].profundidade + 1;
+        let ini = self.n_params;
+        let fim = ini + n_params.max(1);
+        self.nos.push(NoArvore {
+            nome: nome.to_string(),
+            pai: Some(pai),
+            filhos: Vec::new(),
+            ini,
+            fim,
+            profundidade: prof,
+            metricas: HashMap::new(),
+        });
+        self.por_nome.insert(nome.to_string(), idx);
+        self.nos[pai].filhos.push(idx);
+        // aresta dupla pai↔filho (novo id_par)
+        let id_par = self.enlaces.len() / 2;
+        self.adj.push(Vec::new());
+        self.adj[pai].push(self.enlaces.len());
+        self.enlaces.push(Enlace { id_par, de: pai, para: idx });
+        self.adj[idx].push(self.enlaces.len());
+        self.enlaces.push(Enlace { id_par, de: idx, para: pai });
+        // 1 entrada por ENLACE (2 por aresta dupla) — credito/regulacao são
+        // indexadas por enlace, não por aresta
+        self.credito.push(0.0);
+        self.credito.push(0.0);
+        self.regulacao.push(0.0);
+        self.regulacao.push(0.0);
+        self.n_params = fim;
+        idx
+    }
+
     /// **Fundo-topo**: agrega a métrica dos filhos no pai (pós-ordem —
     /// T-A2: a soma na raiz = soma global de todas as folhas + próprias).
     /// Devolve o total agregado na raiz.
+    /// v0.8.0: **ITERATIVA** (proposta Qwen-3.8 nº 2 VALIDADA, com correções
+    /// de robustez) — pilha explícita no heap, SEM recursão e SEM clones de
+    /// `filhos`: O(V+E) tempo, O(V) espaço, zero alocação por nó; segura
+    /// para árvores profundas degeneradas (T-A7b). Equivalência BIT-A-BIT
+    /// com a recursiva (T-A7): mesma ordem de pós-ordem e mesma ordem de
+    /// soma — prova em r-33 §3.
     pub fn agregar_fundo_topo(&mut self, metrica: &str) -> f64 {
+        match self.agregar_pos_ordem(metrica) {
+            Ok(v) => v,
+            Err(e) => {
+                // estrutura malformada (ciclo/filho duplicado): a recursiva
+                // somaria duas vezes ou não terminaria — aqui é explícito
+                log::warn!("agregar_fundo_topo: {e}");
+                f64::NAN
+            }
+        }
+    }
+
+    /// Pós-ordem iterativa com verificação estrutural — erro em ciclo ou
+    /// filho duplicado. O flag `empilhado` é marcado NO MOMENTO DO PUSH:
+    /// um nó empilhado duas vezes (duplicata no mesmo pai, ou re-entrada de
+    /// ciclo) é recusado imediatamente — a marcação pós-expansão deixaria
+    /// escapar o caso "pai lista o filho duas vezes" (o 2º push ocorre
+    /// antes da expansão do 1º — errata da própria correção, r-33 §3.4).
+    fn agregar_pos_ordem(&mut self, metrica: &str) -> Result<f64, String> {
+        let n = self.nos.len();
+        if n == 0 {
+            return Ok(0.0);
+        }
+        // fase 1: ordem de visita (pós-ordem: filhos ANTES do pai)
+        let mut estado = vec![0u8; n]; // 0 = novo, 1 = filhos empilhados
+        let mut empilhado = vec![false; n]; // marcado NO PUSH (unicidade)
+        let mut pilha: Vec<usize> = Vec::with_capacity(n);
+        let mut pos_ordem: Vec<usize> = Vec::with_capacity(n);
+        pilha.push(0usize);
+        empilhado[0] = true;
+        while let Some(&atual) = pilha.last() {
+            if estado[atual] == 0 {
+                estado[atual] = 1;
+                for &f in self.nos[atual].filhos.iter().rev() {
+                    if f >= n {
+                        return Err(format!("filho {f} fora do intervalo (nó {atual})"));
+                    }
+                    if empilhado[f] {
+                        return Err(format!(
+                            "filho {f} duplicado ou ciclo detectado no nó {atual}"
+                        ));
+                    }
+                    empilhado[f] = true;
+                    pilha.push(f);
+                }
+            } else {
+                pilha.pop();
+                pos_ordem.push(atual);
+            }
+        }
+        // fase 2: processa folhas primeiro (a pós-ordem já é fundo-topo)
+        for &no in pos_ordem.iter() {
+            let mut total = self.nos[no].metricas.get(metrica).copied().unwrap_or(0.0);
+            for &f in self.nos[no].filhos.iter() {
+                let v_filho = self.nos[f].metricas.get(metrica).copied().unwrap_or(0.0);
+                total += v_filho; // MESMA ordem da recursiva (bit-a-bit — T-A7)
+                if let Some(e) = self.enlace(f, no) {
+                    self.credito[e] = v_filho; // crédito sobe filho→pai
+                }
+            }
+            self.nos[no].metricas.insert(metrica.to_string(), total);
+        }
+        Ok(self.nos[0].metricas.get(metrica).copied().unwrap_or(0.0))
+    }
+
+    /// Referência RECURSIVA (v0.6.0) — mantida como oráculo de equivalência
+    /// do teste T-A7 e documentação do ganho (não usa em produção: clone de
+    /// `filhos` por nó + quadros de pilha O(profundidade)).
+    pub fn agregar_fundo_topo_rec(&mut self, metrica: &str) -> f64 {
         self.agregar_rec(0, metrica)
     }
 
@@ -201,20 +313,21 @@ impl ArvorePesos {
     /// **Topo-fundo**: regulação desce do nó `origem` com decaimento
     /// λ^k por nível de profundidade relativa (T-A3: causal — desce por
     /// níveis da filtração da árvore; terminante — profundidade finita).
+    /// v0.8.0: ITERATIVA (pré-ordem com pilha explícita — mesmo ganho da
+    /// agregação: sem clones, sem recursão; mesma ordem de escrita).
     pub fn regular_topo_fundo(&mut self, origem: usize, delta: f64, lambda: f64) {
         let base = self.nos[origem].profundidade;
-        self.regular_rec(origem, delta, lambda, base);
-    }
-
-    fn regular_rec(&mut self, no: usize, delta: f64, lambda: f64, base: usize) {
-        let k = self.nos[no].profundidade.saturating_sub(base);
-        let d = delta * lambda.powi(k as i32);
-        let filhos = self.nos[no].filhos.clone();
-        for f in filhos {
-            if let Some(e) = self.enlace(no, f) {
-                self.regulacao[e] = d; // desce pelo enlace pai→filho
+        let mut pilha = vec![origem];
+        while let Some(u) = pilha.pop() {
+            // k do PAI u (semântica v0.6.0 exata: a aresta u→f usa λ^k(u))
+            let k = self.nos[u].profundidade.saturating_sub(base);
+            let d = delta * lambda.powi(k as i32);
+            for &f in self.nos[u].filhos.iter().rev() {
+                if let Some(e) = self.enlace(u, f) {
+                    self.regulacao[e] = d; // desce pelo enlace pai→filho
+                }
+                pilha.push(f);
             }
-            self.regular_rec(f, delta, lambda, base);
         }
     }
 
@@ -282,6 +395,40 @@ impl ArvorePesos {
                 ));
             }
         }
+        // (iv) simetria pai↔filho (v0.8.0 — T-A8): todo filho listado por u
+        // deve ter pai = u (captura o 2-ciclo A↔B anexado à raiz, que as
+        // checagens (i)-(iii) deixam passar)
+        for (u, no) in self.nos.iter().enumerate() {
+            for &f in &no.filhos {
+                if self.nos[f].pai != Some(u) {
+                    return Err(format!(
+                        "nó {u} lista filho {f} cujo pai é {:?} (assimetria)",
+                        self.nos[f].pai
+                    ));
+                }
+            }
+        }
+        // (v) alcançabilidade (v0.8.0 — T-A9): todo nó atingível da raiz —
+        // com pai único + simetria (iv), isso equivale a ACICLICO+conectado
+        let mut visto = vec![false; self.nos.len()];
+        let mut fila = vec![0usize];
+        visto[0] = true;
+        let mut alcancados = 1usize;
+        while let Some(u) = fila.pop() {
+            for &f in &self.nos[u].filhos {
+                if !visto[f] {
+                    visto[f] = true;
+                    alcancados += 1;
+                    fila.push(f);
+                }
+            }
+        }
+        if alcancados != self.nos.len() {
+            return Err(format!(
+                "{} nós inalcançáveis da raiz (ciclo desconectado?)",
+                self.nos.len() - alcancados
+            ));
+        }
         Ok(())
     }
 }
@@ -392,4 +539,128 @@ mod testes {
         let v = a.nos[f].metricas["confianca"];
         assert!((v - 0.0).abs() < 1e-12, "T-A5: 0,1 − 0,1 = 0");
     }
+
+    /// **T-A7 (v0.8.0):** equivalência BIT-A-BIT da agregação iterativa com
+    /// a recursiva em árvores aleatórias (mesma pós-ordem, mesma ordem de
+    /// soma — prova r-33 §3.3). Proposta Qwen-3.8 nº 2 validada.
+    #[test]
+    fn ta7_equivalencia_bit_a_bit() {
+        let mut rng = crate::rng::RngDeterministico::novo(909);
+        for tentativa in 0..8u32 {
+            let mut a = arvore_exemplo();
+            // anexa subárvores aleatórias (ramificação E profundidade)
+            for j in 0..12u32 {
+                let pai = rng.inteiro(a.n_nos());
+                let nome = format!("extra_{tentativa}_{j}");
+                a.anexar_filho(pai, &nome, 1 + rng.inteiro(4));
+            }
+            // métricas locais aleatórias (registradas para repor depois)
+            let locais: Vec<f64> = (0..a.n_nos())
+                .map(|no| {
+                    let v = rng.normal(0.0, 2.0);
+                    a.nos[no].metricas.insert("punicao".into(), v);
+                    v
+                })
+                .collect();
+            let esperado: f64 = locais.iter().sum();
+            a.invariantes_ok().expect("árvore aleatória válida");
+            // iterativa
+            let total_it = a.agregar_fundo_topo("punicao");
+            let credito_it = a.credito.clone();
+            // repõe as métricas locais e roda a recursiva (oráculo v0.6.0)
+            for (no, v) in locais.iter().enumerate() {
+                a.nos[no].metricas.insert("punicao".into(), *v);
+            }
+            let total_rec = a.agregar_fundo_topo_rec("punicao");
+            let credito_rec = a.credito.clone();
+            assert_eq!(
+                total_it.to_bits(), total_rec.to_bits(),
+                "T-A7: total bit-a-bit (tentativa {tentativa}: {total_it} vs {total_rec})"
+            );
+            for (i, (x, y)) in credito_it.iter().zip(credito_rec.iter()).enumerate() {
+                assert_eq!(x.to_bits(), y.to_bits(), "T-A7: crédito[{i}] bit-a-bit");
+            }
+            assert!(
+                (total_it - esperado).abs() < 1e-9,
+                "T-A7: soma global (tentativa {tentativa})"
+            );
+        }
+    }
+
+    /// **T-A7b (v0.8.0):** cadeia degenerada de 100.000 nós — a iterativa
+    /// completa SEM estourar a pilha (a recursiva exigiria ~100k quadros,
+    /// excedendo o limite padrão de 8 MiB — risco documentado da v0.6.0;
+    /// por isso ela NÃO é executada aqui).
+    #[test]
+    fn ta7b_cadeia_profunda_100k() {
+        let mut a = arvore_exemplo();
+        let mut pai = 1usize; // tronco
+        for i in 0..100_000u32 {
+            pai = a.anexar_filho(pai, &format!("c{i}"), 1);
+        }
+        assert_eq!(a.n_nos(), 100_000 + 12);
+        a.nos[pai].metricas.insert("conf".into(), 1.0);
+        let total = a.agregar_fundo_topo("conf");
+        assert!((total - 1.0).abs() < 1e-12, "T-A7b: total {total}");
+        // o crédito sobe INTEIRO por toda a cadeia (T-A2)
+        let e = a.enlace(pai, a.nos[pai].pai.unwrap()).unwrap();
+        assert!((a.credito[e] - 1.0).abs() < 1e-12, "T-A7b: crédito na folha");
+        assert!(a.invariantes_ok().is_ok(), "T-A7b: invariantes na cadeia");
+    }
+
+    /// **T-A7c (v0.8.0):** regulação iterativa preserva a semântica λ^k do
+    /// PAI (v0.6.0) em subárvores de profundidade 3.
+    #[test]
+    fn ta7c_regular_iterativa_equivalente() {
+        let mut a = arvore_exemplo();
+        let n1 = a.anexar_filho(1, "sub1", 2); // profundidade 2 (sob o tronco)
+        let n2 = a.anexar_filho(n1, "sub2", 2); // profundidade 3
+        let _n3 = a.anexar_filho(n2, "sub3", 2); // profundidade 4
+        let raiz = 0usize;
+        a.regular_topo_fundo(raiz, 0.8, 0.5);
+        // aresta raiz→tronco: k(raiz) = 0 ⇒ λ⁰
+        let e = a.enlace(raiz, 1).unwrap();
+        assert!((a.regulacao[e] - 0.8).abs() < 1e-12, "T-A7c: nível raiz");
+        // aresta tronco→sub1: k(tronco) = 1 ⇒ 0,8·0,5
+        let e1 = a.enlace(1, n1).unwrap();
+        assert!((a.regulacao[e1] - 0.4).abs() < 1e-12, "T-A7c: nível 1");
+        // aresta sub1→sub2: k(sub1) = 2 ⇒ 0,8·0,25
+        let e2 = a.enlace(n1, n2).unwrap();
+        assert!((a.regulacao[e2] - 0.2).abs() < 1e-12, "T-A7c: nível 2");
+        assert!(a.invariantes_ok().is_ok());
+    }
+
+    /// **T-A8 (v0.8.0):** detecção de estruturas malformadas — filho
+    /// duplicado (a iterativa recusa; a recursiva somaria DUAS vezes) e
+    /// ciclos (checagens (iv) simetria e (v) alcançabilidade — que as
+    /// checagens (i)-(iii) da v0.6.0 deixavam passar).
+    #[test]
+    fn ta8_deteccao_ciclos_e_duplicatas() {
+        let mut a = arvore_exemplo();
+        // (a) filho duplicado: raiz lista o tronco duas vezes
+        a.nos[0].filhos.push(1);
+        let total = a.agregar_fundo_topo("punicao");
+        assert!(total.is_nan(), "T-A8: duplicata deve recusar (NaN), não somar 2×");
+        a.nos[0].filhos.pop();
+        assert!(a.invariantes_ok().is_ok(), "T-A8: restaurada");
+        // (b) assimetria pai↔filho: tronco lista o quantizador (pai = raiz)
+        a.nos[1].filhos.push(2);
+        let err = a.invariantes_ok().unwrap_err();
+        assert!(err.contains("assimetria"), "T-A8(iv): {err}");
+        a.nos[1].filhos.pop();
+        // (c) 2-ciclo desconectado x↔y: passa (i)-(iv), capturado por (v)
+        let x = a.nos.len();
+        let y = x + 1;
+        a.nos.push(NoArvore {
+            nome: "x".into(), pai: Some(y), filhos: vec![y],
+            ini: 94, fim: 95, profundidade: 9, metricas: HashMap::new(),
+        });
+        a.nos.push(NoArvore {
+            nome: "y".into(), pai: Some(x), filhos: vec![x],
+            ini: 95, fim: 96, profundidade: 9, metricas: HashMap::new(),
+        });
+        a.n_params = 96;
+        let err = a.invariantes_ok().unwrap_err();
+        assert!(err.contains("inalcançáveis"), "T-A8(v): {err}");
+    }
 }

src/fnh.rs

@@ -58,6 +58,21 @@ impl Ativacao {
     }
 }
 
+/// Modo de construção da rotação (v0.8.0 — proposta Qwen-3.8 nº 3).
+/// O padrão `Polar` preserva a semântica v0.7.0 bit-a-bit (port fiel do
+/// gru-ring: série truncada projetada ao SO(n)); `Cayley` é a alternativa
+/// algébrica EXATA sem série infinita (ver `rotacao_cayley`).
+#[derive(Clone, Copy, Debug, PartialEq, Default)]
+pub enum ModoRotacao {
+    /// R = polar(I + A + A²/2 + A³/6) — Newton–Schulz (~82 matmuls n³).
+    #[default]
+    Polar,
+    /// R = (I − A/2)(I + A/2)⁻¹ — Cayley (Teo F-9); inversão pela iteração
+    /// de Newton X ← X(2I − MX) com saída antecipada (típico 3–8 matmuls
+    /// duplos, teto 12) — diferenciável e EXATA em aritmética exata.
+    Cayley,
+}
+
 /// Rotação aprendível em SO(n): R = polar(I + A + A²/2 + A³/6) com A skew
 /// parametrizada por θ ∈ R^{n(n−1)/2} (port de `SkewRotation`; a retração
 /// polar é o acréscimo v0.7.0 — Teo F-1).
@@ -70,6 +85,10 @@ pub struct RotacaoSkew {
     pub clamp_theta: f64,
     /// iterações Newton–Schulz da retração polar.
     pub iters_polar: usize,
+    /// modo de construção (v0.8.0 — padrão Polar: compatibilidade v0.7.0).
+    pub modo: ModoRotacao,
+    /// teto de iterações da inversão de Newton do modo Cayley (F-10).
+    pub iters_cayley: usize,
 }
 
 impl RotacaoSkew {
@@ -80,6 +99,8 @@ impl RotacaoSkew {
             n,
             clamp_theta: 0.5,
             iters_polar: 40,
+            modo: ModoRotacao::Polar,
+            iters_cayley: 12,
         })
     }
 
@@ -112,6 +133,16 @@ impl RotacaoSkew {
         Ok(tri.sub(&tri.transpose(0, 1)?)?) // A = U − Uᵀ (skew exato)
     }
 
+    /// R ∈ SO(n) no modo configurado (v0.8.0: despacha para polar ou
+    /// Cayley — mesmo contrato: ortogonal exata, nascimento neutro,
+    /// diferenciável em θ).
+    pub fn rotacao(&self) -> Result<Tensor> {
+        match self.modo {
+            ModoRotacao::Polar => self.rotacao_polar(),
+            ModoRotacao::Cayley => self.rotacao_cayley(),
+        }
+    }
+
     /// R = polar(expm_trunc(A)) ∈ SO(n) EXATO (δ_ort ≤ 1e-6 — teste F-1).
     /// Diferenciável em θ (todas as ops são matmul/afim — autograd flui).
     /// Atalho de nascimento: se o valor do truncado é EXATAMENTE I (θ=0 ⇒
@@ -119,7 +150,7 @@ impl RotacaoSkew {
     /// (evita a flakiness da σ aleatória da iteração de potência, 3% dos
     /// casos deixa resíduo ~1e-8) e o GRAFO permanece conectado a θ
     /// (gradiente flui — sem deadlock).
-    pub fn rotacao(&self) -> Result<Tensor> {
+    pub fn rotacao_polar(&self) -> Result<Tensor> {
         let a = self.skew()?;
         let a2 = a.matmul(&a)?;
         let a3 = a2.matmul(&a)?;
@@ -136,12 +167,106 @@ impl RotacaoSkew {
         retrair_polar(&trunc, self.iters_polar)
     }
 
+    /// **F-9/F-10 (v0.8.0):** Transformada de Cayley
+    /// `R = (I + A/2)(I − A/2)⁻¹` com A = skew(θ) — proposta Qwen-3.8 nº 3
+    /// CORRIGIDA em DOIS pontos: (a) candle 0.11 **não possui `Tensor::inv()``
+    /// (a proposta assumia a API) — a inversão é feita pela iteração de
+    /// Newton para inversos `X ← X(2I − MX)`, 100% diferenciável, com
+    /// escalonamento inicial `X₀ = αMᵀ, α = 1/(1+‖B‖²_F)` de convergência
+    /// PROVADA (F-10); (b) **convenção de sinal** — a forma original
+    /// `(I − A/2)(I + A/2)⁻¹` é ortogonal, mas equivale a `expm(−A + O(A³))`
+    /// (identidade escalar (1−t)/(1+t) = e^{−2·artanh t} elevada a matrizes
+    /// comutantes); a forma aqui adotada `(I + A/2)(I − A/2)⁻¹ = expm(+A +
+    /// O(A³))` preserva a paridade com a série de Taylor do gru-ring
+    /// (verificado contra oráculo NumPy/SVD — r-33 §4.6).
+    ///
+    /// Propriedades (provas r-33 §4):
+    /// - **SO(n) exato em aritmética exata**: RᵀR = I e det R = +1
+    ///   (comutação de polinômios em A; F-9.ii/iii);
+    /// - **Denominador sempre invertível E bem condicionado**: eig(I−A/2)
+    ///   = 1 ± iλ/2 ⇒ |eig| = √(1+λ²/4) ≥ 1 ⇒ κ ≤ √(1+‖A‖₂²/4), limitado
+    ///   pelo clamp — sem necessidade de LU/pivoteamento (F-9.iv);
+    /// - **Nascimento neutro**: θ=0 ⇒ B=0 ⇒ α=1 ⇒ X₀=Mᵀ=I e o resíduo
+    ///   |1−α| = 0 já encerra na 1ª iteração ⇒ R = I bit-a-bit COM o grafo
+    ///   conectado a θ (gradiente flui no nascimento — melhor que o atalho
+    ///   do polar, que precisa de caso especial);
+    /// - **Limitação honesta**: −1 nunca é autovalor (ângulo exatamente π é
+    ///   inatingível — conjunto de medida zero, irrelevante ao treino).
+    pub fn rotacao_cayley(&self) -> Result<Tensor> {
+        let a = self.skew()?;
+        let dev = a.device();
+        let ident = Tensor::eye(self.n, DType::F32, &dev)?;
+        let half = a.affine(0.5, 0.0)?; // B = A/2 (skew)
+        let m = ident.sub(&half)?; // M = I − A/2 — invertível (F-9.i)
+        // X₀ = αMᵀ com α = 1/(1+‖B‖²_F) ⇒ ‖I − MX₀‖₂ < 1 (F-10)
+        let bf2 = half.sqr()?.sum_all()?.to_scalar::<f32>()? as f64;
+        let alpha = 1.0 / (1.0 + bf2);
+        let mut x = m.transpose(0, 1)?.affine(alpha, 0.0)?;
+        // Newton para inversos: E_{k+1} = E_k² (quadrático); saída
+        // antecipada quando o resíduo ‖I − MX‖∞ < 1e-7 (típico: 1–3 iters
+        // perto do nascimento; ≤ 9 no pior caso do clamp, teto 12)
+        for _ in 0..self.iters_cayley {
+            let mx = m.matmul(&x)?;
+            let residuo = (&ident - &mx)?.abs()?.max_all()?.to_scalar::<f32>()? as f64;
+            if residuo < 1e-7 {
+                break;
+            }
+            // 2I − MX: soma 2 SÓ na diagonal (affine somaria em TODAS as
+            // entradas — bug corrigido: 2·J − MX diverge)
+            let dois_i_menos = ident.affine(2.0, 0.0)?.sub(&mx)?;
+            x = x.matmul(&dois_i_menos)?;
+        }
+        let num = ident.add(&half)?; // I + A/2
+        num.matmul(&x) // R = (I + A/2)(I − A/2)⁻¹ ≈ expm(+A)
+    }
+
     /// δ_ort(R) = ‖RᵀR − I‖_F (monitor).
     pub fn erro_ortogonalidade(&self) -> Result<f64> {
         erro_ortogonalidade(&self.rotacao()?)
     }
 }
 
+/// **F-11 (v0.8.0):** rotação por planos canônicos (bloco-diagonal 2×2)
+/// via Cayley em fórmula FECHADA — SEM inversão de matriz e SEM iterações.
+/// Com s_k = θ_k/2:
+/// `R = ⊕_k 1/(1+s_k²) · [[1−s_k², −2s_k], [2s_k, 1−s_k²]]`
+/// (inversão analítica exata de [[1, s], [−s, 1]]; convenção expm(+A) —
+/// Teo F-11 — r-33 §4.5).
+/// `theta_planos`: (n/2,) — a rotação age em n/2 planos canônicos sem
+/// mistura entre eles (família RESTRITA, n/2 graus de liberdade).
+/// Diferenciável (elementwise + 1 matmul de seleção) e nascimento neutro
+/// (θ=0 ⇒ R = I bit-a-bit com grafo conectado a θ). Indicada quando o
+/// custo O(n³) das rotações completas domina (n grande).
+pub fn rotacao_cayley_bloco(theta_planos: &Tensor) -> Result<Tensor> {
+    let dev = theta_planos.device();
+    let m = theta_planos.elem_count();
+    let n = 2 * m;
+    // s = θ/2; c = (1−s²)/(1+s²); t = 2s/(1+s²) — elementwise, grafo VIVO
+    let s = theta_planos.flatten_all()?.affine(0.5, 0.0)?;
+    let s2 = s.sqr()?;
+    let um_menos = s2.affine(-1.0, 1.0)?; // 1−s²
+    let um_mais = s2.affine(1.0, 1.0)?; // 1+s²
+    let c = um_menos.broadcast_div(&um_mais)?;
+    let t = s.affine(2.0, 0.0)?.broadcast_div(&um_mais)?;
+    // intercala [c_0, t_0, c_1, t_1, ...] → (1, 2m)
+    let par = Tensor::stack(&[&c, &t], 0)? // (2, m)
+        .transpose(0, 1)? // (m, 2) = [[c_0, t_0], ...]
+        .reshape((1, 2 * m))?;
+    // matriz de seleção S (2m, n²) CONSTANTE: linha 2k (c_k) marca as
+    // diagonais do bloco k; linha 2k+1 (t_k) marca (−acima, +abaixo)
+    // (convenção expm(+A): R_k = [[c, −t], [t, c]])
+    let mut sel = vec![0f32; 2 * m * n * n];
+    for k in 0..m {
+        let (a, b) = (2 * k, 2 * k + 1);
+        sel[2 * k * n * n + a * n + a] = 1.0;
+        sel[2 * k * n * n + b * n + b] = 1.0;
+        sel[(2 * k + 1) * n * n + a * n + b] = -1.0;
+        sel[(2 * k + 1) * n * n + b * n + a] = 1.0;
+    }
+    let s_mat = Tensor::from_vec(sel, (2 * m, n * n), &dev)?;
+    Ok(par.matmul(&s_mat)?.reshape((n, n))?)
+}
+
 /// SmoothQuant (Xiao et al. 2022) — port do `SmoothQuantCompressor`.
 /// s_j = max|X_j|^α / max|W_j|^(1−α) via EMA; a migração compensada
 /// (W·diag(s), X/diag(s)) é EXATAMENTE neutra na saída (Teo F-6 — prova
@@ -598,4 +723,231 @@ mod testes {
         assert!(mx.is_finite() && mx > 0.0, "F-8: saída quantizada finita");
         Ok(())
     }
+
+    /// determinante por eliminação gaussiana em f64 (auxiliar dos testes).
+    fn det_f64(t: &Tensor) -> f64 {
+        let n = t.dims()[0];
+        let mut m: Vec<Vec<f64>> = t
+            .to_vec2::<f32>()
+            .unwrap()
+            .iter()
+            .map(|r| r.iter().map(|x| *x as f64).collect())
+            .collect();
+        let mut det = 1.0;
+        for col in 0..n {
+            let mut pivo = col;
+            for r in col + 1..n {
+                if m[r][col].abs() > m[pivo][col].abs() {
+                    pivo = r;
+                }
+            }
+            if m[pivo][col].abs() < 1e-12 {
+                return 0.0;
+            }
+            if pivo != col {
+                m.swap(pivo, col);
+                det = -det;
+            }
+            det *= m[col][col];
+            for r in col + 1..n {
+                let f = m[r][col] / m[col][col];
+                for c in col..n {
+                    m[r][c] -= f * m[col][c];
+                }
+            }
+        }
+        det
+    }
+
+    /// inversão Gauss–Jordan em f64 (auxiliar — oráculo do teste F-10).
+    fn inv_f64(t: &Tensor) -> Vec<Vec<f64>> {
+        let n = t.dims()[0];
+        let mut a: Vec<Vec<f64>> = t
+            .to_vec2::<f32>()
+            .unwrap()
+            .iter()
+            .map(|r| r.iter().map(|x| *x as f64).collect())
+            .collect();
+        let mut inv = vec![vec![0.0; n]; n];
+        for i in 0..n {
+            inv[i][i] = 1.0;
+        }
+        for col in 0..n {
+            let mut pivo = col;
+            for r in col + 1..n {
+                if a[r][col].abs() > a[pivo][col].abs() {
+                    pivo = r;
+                }
+            }
+            a.swap(pivo, col);
+            inv.swap(pivo, col);
+            let p = a[col][col];
+            for c in 0..n {
+                a[col][c] /= p;
+                inv[col][c] /= p;
+            }
+            for r in 0..n {
+                if r != col && a[r][col].abs() > 1e-15 {
+                    let f = a[r][col];
+                    for c in 0..n {
+                        a[r][c] -= f * a[col][c];
+                        inv[r][c] -= f * inv[col][c];
+                    }
+                }
+            }
+        }
+        inv
+    }
+
+    /// **F-9 (v0.8.0):** Cayley ∈ SO(n) — δ_ort ≤ 1e-6, det = +1, e
+    /// nascimento I bit-a-bit COM o grafo conectado a θ (gradiente flui —
+    /// propriedade que a forma fechada dá de graça, sem o atalho especial
+    /// do caminho polar). Perda assimétrica ⟨W, R⟩ para expor o sinal.
+    #[test]
+    fn f9_cayley_so_n_exato() -> Result<()> {
+        let dev = Device::Cpu;
+        let r = RotacaoSkew::nova(12, &dev)?;
+        let th: Vec<f32> = (0..12 * 11 / 2).map(|i| ((i as f32) * 0.07) % 0.5).collect();
+        r.theta.set(&Tensor::from_vec(th, (12 * 11 / 2,), &dev)?)?;
+        let rot = r.rotacao_cayley()?;
+        let delta = erro_ortogonalidade(&rot)?;
+        assert!(delta < 1e-6, "F-9: δ_ort = {delta} (esperado ≤ 1e-6)");
+        let d = det_f64(&rot);
+        assert!((d - 1.0).abs() < 1e-4, "F-9: det = {d} (deve ser +1)");
+        // nascimento: θ=0 ⇒ R = I bit-a-bit (α=1 exato ⇒ 1ª iteração encerra)
+        let r0 = RotacaoSkew::nova(8, &dev)?;
+        let ident = r0.rotacao_cayley()?;
+        let dif = (&ident - &Tensor::eye(8, DType::F32, &dev)?)?
+            .abs()?
+            .max_all()?
+            .to_scalar::<f32>()?;
+        assert_eq!(dif, 0.0, "F-9: θ=0 ⇒ R = I bit-a-bit");
+        // grafo VIVO no nascimento: ⟨W, R⟩ com W não-simétrico ⇒ grad ≠ 0
+        let mut rng2 = rng();
+        let w = randn(&mut rng2, &[8, 8], &dev)?;
+        let perda = (&w * &ident)?.sum_all()?;
+        let grads = perda.backward()?;
+        let g = grads
+            .get(&r0.theta)
+            .map(|t| t.flatten_all().unwrap().to_vec1::<f32>().unwrap())
+            .unwrap_or_default();
+        assert!(
+            g.iter().any(|v| v.abs() > 1e-9),
+            "F-9: gradiente flui a θ no nascimento (grafo conectado sem atalho)"
+        );
+        Ok(())
+    }
+
+    /// **F-10 (v0.8.0):** Newton-inverso converge no PIOR CASO do clamp
+    /// (todos os θ = 0,5) e o resultado confere com a inversão explícita
+    /// Gauss–Jordan em f64.
+    #[test]
+    fn f10_newton_inverso_pior_caso() -> Result<()> {
+        let dev = Device::Cpu;
+        let n = 16;
+        let r = RotacaoSkew::nova(n, &dev)?;
+        let th: Vec<f32> = vec![0.5f32; n * (n - 1) / 2];
+        r.theta.set(&Tensor::from_vec(th, (n * (n - 1) / 2,), &dev)?)?;
+        let rot = r.rotacao_cayley()?;
+        let delta = erro_ortogonalidade(&rot)?;
+        assert!(delta < 1e-6, "F-10: δ_ort pior caso = {delta}");
+        // oráculo explícito: R = (I + B)·(I − B)⁻¹ em f64 (convenção expm(+A))
+        let a = r.skew()?;
+        let av = a.to_vec2::<f32>()?;
+        let mut b = vec![vec![0.0f64; n]; n];
+        for i in 0..n {
+            for j in 0..n {
+                b[i][j] = 0.5 * av[i][j] as f64;
+            }
+        }
+        let bt = Tensor::from_vec(
+            b.iter().flatten().map(|x| *x as f32).collect::<Vec<f32>>(),
+            (n, n),
+            &dev,
+        )?;
+        let um_b = Tensor::eye(n, DType::F32, &dev)?.add(&bt)?;
+        let um_menos_b = Tensor::eye(n, DType::F32, &dev)?.sub(&bt)?;
+        let inv = inv_f64(&um_menos_b);
+        let inv_t = Tensor::from_vec(
+            inv.iter().flatten().map(|x| *x as f32).collect::<Vec<f32>>(),
+            (n, n),
+            &dev,
+        )?;
+        let explicito = um_b.matmul(&inv_t)?;
+        let dif = (&rot - &explicito)?.abs()?.max_all()?.to_scalar::<f32>()?;
+        assert!(dif < 1e-3, "F-10: max|R_newton − R_gaussjordan| = {dif}");
+        Ok(())
+    }
+
+    /// **F-11 (v0.8.0):** bloco 2×2 — ortogonal exata, bloque-diagonal
+    /// (zero fora dos planos), nascimento I bit-a-bit, gradiente flui.
+    #[test]
+    fn f11_cayley_bloco() -> Result<()> {
+        let dev = Device::Cpu;
+        let th = Tensor::from_vec(vec![0.3f32, -0.7, 1.2, 0.05], (4,), &dev)?;
+        let r = rotacao_cayley_bloco(&th)?;
+        assert_eq!(r.dims(), [8, 8], "F-11: 4 planos ⇒ 8×8");
+        let delta = erro_ortogonalidade(&r)?;
+        assert!(delta < 1e-6, "F-11: δ_ort = {delta}");
+        // estrutura bloque-diagonal: zero EXATO fora dos blocos 2×2
+        let rv = r.to_vec2::<f32>()?;
+        for i in 0..8 {
+            for j in 0..8 {
+                if (i / 2) != (j / 2) {
+                    assert_eq!(rv[i][j], 0.0, "F-11: fora do bloco ({i},{j})");
+                }
+            }
+        }
+        // nascimento: θ=0 ⇒ R = I bit-a-bit
+        let th_var = Var::from_tensor(&Tensor::zeros((4,), DType::F32, &dev)?)?;
+        let rz = rotacao_cayley_bloco(th_var.as_tensor())?;
+        let dif = (&rz - &Tensor::eye(8, DType::F32, &dev)?)?
+            .abs()?
+            .max_all()?
+            .to_scalar::<f32>()?;
+        assert_eq!(dif, 0.0, "F-11: nascimento neutro bit-a-bit");
+        // grafo vivo: gradiente de ⟨W, R⟩ em θ flui
+        let mut rng2 = rng();
+        let w = randn(&mut rng2, &[8, 8], &dev)?;
+        let perda = (&w * &rz)?.sum_all()?;
+        let grads = perda.backward()?;
+        let g = grads
+            .get(&th_var)
+            .map(|t| t.flatten_all().unwrap().to_vec1::<f32>().unwrap())
+            .unwrap_or_default();
+        assert!(
+            g.iter().any(|v| v.abs() > 1e-9),
+            "F-11: gradiente flui a θ (grafo conectado)"
+        );
+        Ok(())
+    }
+
+    /// **F-12 (v0.8.0):** Cayley ≈ polar para θ pequeno (ambos ≈ expm(+A) —
+    /// com a convenção corrigida F-9(b): polar-série com erro O(θ⁴),
+    /// Cayley = expm(2·artanh(A/2)) = expm(+A − A³/12 + O(A⁵)); a distância
+    /// mútua é O(‖A‖³/12), verificada contra oráculo NumPy/SVD — r-33 §4.6).
+    #[test]
+    fn f12_cayley_vs_polar_teta_pequeno() -> Result<()> {
+        let dev = Device::Cpu;
+        let n = 8;
+        let r = RotacaoSkew::nova(n, &dev)?;
+        let th: Vec<f32> = (0..n * (n - 1) / 2).map(|i| 0.02 + 0.005 * i as f32).collect();
+        r.theta.set(&Tensor::from_vec(th, (n * (n - 1) / 2,), &dev)?)?;
+        let rp = r.rotacao_polar()?;
+        let rc = r.rotacao_cayley()?;
+        let dif = (&rp - &rc)?.sqr()?.sum_all()?.to_scalar::<f32>()?.sqrt();
+        let d_id = (&rp - &Tensor::eye(n, DType::F32, &dev)?)?
+            .sqr()?
+            .sum_all()?
+            .to_scalar::<f32>()?
+            .sqrt();
+        assert!(
+            dif < 2e-2,
+            "F-12: ‖R_polar − R_cayley‖_F = {dif} (θ pequeno deve coincidir)"
+        );
+        // honestidade: desvio O(‖A‖³/12) contra distância O(‖A‖) à identidade
+        let razao = dif / d_id.max(1e-9);
+        assert!(razao < 0.25, "F-12: razão desvio/distância = {razao}");
+        Ok(())
+    }
 }

src/lib.rs

@@ -45,7 +45,7 @@ pub mod build_info {
 
 #[pyfunction]
 fn versao() -> &'static str {
-    "0.7.0 (KHTST_RUST — FNH com gate de punição + árvore de pesos indexada c/ arestas duplas + quebra-cabeça do Pensamento + NLP/NLG + decodificador especulativo + auto-ajuste SOM limitado + correções v070-1/2/3)"
+    "khtst-rust-0.8.0"
 }
 
 #[pyfunction]
@@ -1967,6 +1967,201 @@ fn demo_autoajuste_som(py: Python) -> PyResult<PyObject> {
     Ok(pythonize::pythonize(py, &d_)?.into())
 }
 
+/// **v0.8.0 — análise/prova/teste das 4 propostas Qwen3.8** (r-33): mede
+/// custo e exatidão de (1) Newton analítico vs golden-section (verificador),
+/// (2) Cayley vs polar (FNH), (3) árvore pós-ordem iterativa vs recursiva,
+/// (4) MoE vetorizada vs referência (valores + gradiente restaurado — bug
+/// v080-1), e re-executa a ablação JEPA de 3 braços com a correção.
+#[pyfunction]
+fn demo_qwen_v080(py: Python) -> PyResult<PyObject> {
+    use candle_core::{Device, Tensor};
+    use std::time::Instant;
+    let dev = Device::Cpu;
+
+    // ---------- (1) Newton vs golden-section (verificador) ----------
+    let mut rng = crate::rng::RngDeterministico::novo(808);
+    let (n, k) = (1024usize, 32usize);
+    let mut lv = Vec::with_capacity(n * k);
+    let mut av = Vec::with_capacity(n);
+    for _ in 0..n {
+        let alvo = rng.inteiro(k) as u32;
+        av.push(alvo);
+        for j in 0..k {
+            let base = if j as u32 == alvo { 3.0 } else { 0.0 };
+            lv.push(base + rng.normal(0.0, 1.0) as f32);
+        }
+    }
+    let lt = Tensor::from_vec(lv, (n, k), &dev).unwrap();
+    let at = Tensor::from_vec(av, (n,), &dev).unwrap();
+    let t0 = Instant::now();
+    let (t_g, _, nll_g) = verificador::calibrar_temperatura(&lt, &at).unwrap();
+    let tempo_golden = t0.elapsed().as_secs_f64();
+    let t0 = Instant::now();
+    let (t_n, _, nll_n, n_aval) =
+        verificador::calibrar_temperatura_newton(&lt, &at, 40).unwrap();
+    let tempo_newton = t0.elapsed().as_secs_f64();
+
+    // ---------- (2) Cayley vs polar (FNH) ----------
+    let n_rot = 16usize;
+    let r = fnh::RotacaoSkew::nova(n_rot, &dev).unwrap();
+    let th: Vec<f32> = (0..n_rot * (n_rot - 1) / 2)
+        .map(|i| ((i as f32) * 0.11) % 0.5)
+        .collect();
+    r.theta
+        .set(&Tensor::from_vec(th, (n_rot * (n_rot - 1) / 2,), &dev).unwrap())
+        .unwrap();
+    let rep = 25usize;
+    let t0 = Instant::now();
+    let mut delta_polar = 0.0;
+    for _ in 0..rep {
+        delta_polar = crate::stiefel::erro_ortogonalidade(&r.rotacao_polar().unwrap()).unwrap();
+    }
+    let tempo_polar = t0.elapsed().as_secs_f64() / rep as f64;
+    let t0 = Instant::now();
+    let mut delta_cayley = 0.0;
+    for _ in 0..rep {
+        delta_cayley = crate::stiefel::erro_ortogonalidade(&r.rotacao_cayley().unwrap()).unwrap();
+    }
+    let tempo_cayley = t0.elapsed().as_secs_f64() / rep as f64;
+
+    // ---------- (3) árvore iterativa vs recursiva ----------
+    let mut arv = arvore_pesos::ArvorePesos::nova(&std::collections::HashMap::new());
+    let mut pai = 1usize;
+    for i in 0..20_000u32 {
+        pai = arv.anexar_filho(pai, &format!("c{i}"), 1);
+    }
+    arv.nos[pai].metricas.insert("m".into(), 1.0);
+    let t0 = Instant::now();
+    let total_it = arv.agregar_fundo_topo("m");
+    let tempo_arv_it = t0.elapsed().as_secs_f64();
+    // repõe TODAS as métricas locais (a agregação sobrescreveu com os
+    // agregados) — só a folha tem valor; o resto volta a 0 — e roda a
+    // recursiva (profundidade 20k ok na thread principal do Python)
+    for no in arv.nos.iter_mut() {
+        no.metricas.insert("m".into(), 0.0);
+    }
+    arv.nos[pai].metricas.insert("m".into(), 1.0);
+    let t0 = Instant::now();
+    let total_rec = arv.agregar_fundo_topo_rec("m");
+    let tempo_arv_rec = t0.elapsed().as_secs_f64();
+
+    // ---------- (4) MoE vetorizada: valores + gradiente + custo ----------
+    let (nm, dm, em) = (256usize, 32usize, 8usize);
+    let xv: Vec<f32> = (0..nm * dm).map(|_| rng.normal(0.0, 1.0) as f32).collect();
+    let x = Tensor::from_vec(xv, (nm, dm), &dev).unwrap();
+    let moe = moe_redirecionavel::MoeRedirecionavel::novo(dm, em, 2, nm, &dev).unwrap();
+    let s_ref = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap();
+    let s_vet = moe.fwd_vetorizado(&x, moe_redirecionavel::Papel::Codificador).unwrap();
+    let dif_moe = (&s_ref.saida - &s_vet.saida)
+        .unwrap()
+        .abs()
+        .unwrap()
+        .max_all()
+        .unwrap()
+        .to_scalar::<f32>()
+        .unwrap() as f64;
+    let rep_moe = 10usize;
+    let t0 = Instant::now();
+    for _ in 0..rep_moe {
+        let _ = moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap();
+    }
+    let tempo_moe_ref = t0.elapsed().as_secs_f64() / rep_moe as f64;
+    let t0 = Instant::now();
+    for _ in 0..rep_moe {
+        let _ = moe.fwd_vetorizado(&x, moe_redirecionavel::Papel::Codificador).unwrap();
+    }
+    let tempo_moe_vet = t0.elapsed().as_secs_f64() / rep_moe as f64;
+    // normas de gradiente (bug v080-1: fwd = 0; vetorizada > 0)
+    let norma = |vet: bool| -> (f64, f64) {
+        let s = if vet {
+            moe.fwd_vetorizado(&x, moe_redirecionavel::Papel::Codificador).unwrap()
+        } else {
+            moe.fwd(&x, moe_redirecionavel::Papel::Codificador).unwrap()
+        };
+        let perda = s.saida.sqr().unwrap().sum_all().unwrap();
+        let gs = perda.backward().unwrap();
+        let mut nr = 0.0;
+        for v in moe.roteador.vars() {
+            if let Some(g) = gs.get(&v) {
+                nr += g.sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap() as f64;
+            }
+        }
+        let mut ne = 0.0;
+        for e in &moe.especialistas {
+            for v in e.vars() {
+                if let Some(g) = gs.get(&v) {
+                    ne += g.sqr().unwrap().sum_all().unwrap().to_scalar::<f32>().unwrap() as f64;
+                }
+            }
+        }
+        (nr, ne)
+    };
+    let (grad_ref_r, grad_ref_e) = norma(false);
+    let (grad_vet_r, grad_vet_e) = norma(true);
+
+    // ---------- (5) re-ablação JEPA 3 braços (gradiente restaurado) ----------
+    let xv: Vec<f32> = (0..64 * 12).map(|_| rng.normal(0.0, 1.0) as f32).collect();
+    let xj = Tensor::from_vec(xv, (64, 12), &dev).unwrap();
+    let mut ablac = serde_json::Map::new();
+    for modo in ["pequena", "densa", "moe"] {
+        let rj = moe_redirecionavel::treinar_jepa_com_moe(&xj, modo, 120, 0.5, 42).unwrap();
+        ablac.insert(
+            modo.into(),
+            serde_json::json!({
+                "perda_inicial": rj.perda_pred_inicial,
+                "perda_final": rj.perda_pred_final,
+                "queda_pct": 100.0 * (1.0 - rj.perda_pred_final / rj.perda_pred_inicial.max(1e-9)),
+            }),
+        );
+    }
+
+    let d_ = serde_json::json!({
+        "versao": "qwen-v080-1.0",
+        "newton_vs_golden": {
+            "t_golden": t_g, "t_newton": t_n, "dif_t": (t_g - t_n).abs(),
+            "nll_golden": nll_g, "nll_newton": nll_n,
+            "nll_dif": (nll_g - nll_n).abs(),
+            "n_aval_newton": n_aval,
+            "tempo_golden_s": tempo_golden, "tempo_newton_s": tempo_newton,
+            "speedup": tempo_golden / tempo_newton.max(1e-9),
+            "gates": {
+                "mesmo_t": (t_g - t_n).abs() < 1e-3,
+                "nll_nao_piora": nll_n <= nll_g + 1e-4,
+                "menos_avaliacoes": n_aval < 36,
+            },
+        },
+        "cayley_vs_polar": {
+            "delta_ort_polar": delta_polar, "delta_ort_cayley": delta_cayley,
+            "tempo_polar_s": tempo_polar, "tempo_cayley_s": tempo_cayley,
+            "speedup": tempo_polar / tempo_cayley.max(1e-9),
+            "gates": {
+                "ambos_exatos": delta_polar < 1e-6 && delta_cayley < 1e-6,
+                "cayley_mais_rapido": tempo_cayley < tempo_polar,
+            },
+        },
+        "arvore_iter_vs_rec": {
+            "n_nos": arv.n_nos(),
+            "total_iter": total_it, "total_rec": total_rec,
+            "bit_a_bit": total_it.to_bits() == total_rec.to_bits(),
+            "tempo_iter_s": tempo_arv_it, "tempo_rec_s": tempo_arv_rec,
+            "gates": { "iguais_bit_a_bit": total_it == total_rec },
+        },
+        "moe_vetorizada": {
+            "max_dif_valores": dif_moe,
+            "tempo_ref_s": tempo_moe_ref, "tempo_vet_s": tempo_moe_vet,
+            "grad_roteador_ref": grad_ref_r, "grad_especialistas_ref": grad_ref_e,
+            "grad_roteador_vet": grad_vet_r, "grad_especialistas_vet": grad_vet_e,
+            "gates": {
+                "valores_iguais": dif_moe < 1e-4,
+                "bug_v080_1_confirmado": grad_ref_r == 0.0 && grad_ref_e == 0.0,
+                "gradiente_restaurado": grad_vet_r > 0.0 && grad_vet_e > 0.0,
+            },
+        },
+        "ablacao_jepa_3_bracos_v080": ablac,
+    });
+    Ok(pythonize::pythonize(py, &d_)?.into())
+}
+
 #[pymodule]
 fn nucleo_rust(m: &Bound<'_, PyModule>) -> PyResult<()> {
     pyo3_log::init();
@@ -2011,6 +2206,8 @@ fn nucleo_rust(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(quebra_cabeca_real, m)?)?;
     m.add_function(wrap_pyfunction!(demo_nlp_nlg, m)?)?;
     m.add_function(wrap_pyfunction!(demo_autoajuste_som, m)?)?;
+    // v0.8.0 — análise/prova/teste das propostas Qwen3.8
+    m.add_function(wrap_pyfunction!(demo_qwen_v080, m)?)?;
     m.add_class::<BpePy>()?;
     m.add_class::<ConfigPy>()?;
     m.add_class::<PonteDuplaPy>()?;

src/moe_redirecionavel.rs

@@ -189,6 +189,13 @@ impl MoeRedirecionavel {
 
     /// Passada por papel: atenção própria → roteamento top-k DENTRO do
     /// subconjunto de especialistas do papel → capacidade → soma ponderada.
+    ///
+    /// ⚠️ **v0.8.0 — bug v080-1 catalogado (r-33 §5):** esta versão
+    /// materializa os valores com `to_vec2`/`from_vec` no acúmulo, o que
+    /// SECCIONA o grafo de autograd — especialistas e roteador NÃO recebem
+    /// gradiente por esta saída (só a atenção própria treina). Mantida como
+    /// referência de VALORES (o teste M-R6 verifica a equivalência numérica
+    /// com a versão vetorizada); para TREINO use `fwd_vetorizado`.
     pub fn fwd(&self, x: &Tensor, papel: Papel) -> Result<SaidaMoeR> {
         let y = self.atencao.fwd(x)?; // (n, d) — atenção própria independente
         let n = y.dim(0)?;
@@ -196,7 +203,6 @@ impl MoeRedirecionavel {
         let dev = y.device();
         let do_papel = self.indices_do_papel(papel);
         let e_local = do_papel.len();
-        let mut carga = vec![0usize; self.especialistas.len()];
         let mut descartados = 0usize;
         let mut saida = Tensor::zeros((n, d), candle_core::DType::F32, &dev)?;
         let mut peso_total = Tensor::zeros((n, 1), candle_core::DType::F32, &dev)?;
@@ -225,34 +231,18 @@ impl MoeRedirecionavel {
                 }
             })
             .collect();
-        // roteamento top-k dentro do papel, com capacidade por especialista
-        let mut usados: Vec<usize> = Vec::new();
-        for (local_e, &ei) in do_papel.iter().enumerate() {
-            let _ = local_e;
-            // candidatos ordenados por prob do especialista ei
-            let mut cand: Vec<(usize, f32)> = (0..n).map(|i| (i, probs[i][ei])).collect();
-            cand.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
-            let mut escolhidos: Vec<usize> = Vec::new();
-            for (i, _) in cand {
-                if carga[ei] >= self.capacidade {
-                    break;
-                }
-                // ei ∈ top-k(papel) do token i?
-                let mut ordem: Vec<(f32, usize)> = do_papel
-                    .iter()
-                    .map(|&g| (probs[i][g], g))
-                    .collect();
-                ordem.sort_by(|a, b| b.0.partial_cmp(&a.0).unwrap());
-                let top: Vec<usize> = ordem.iter().rev().take(self.n_top).map(|(_, g)| *g).collect();
-                if top.contains(&ei) {
-                    escolhidos.push(i);
-                    carga[ei] += 1;
-                }
-            }
-            if escolhidos.is_empty() {
-                continue;
-            }
-            usados.push(ei);
+        // seleção top-k com capacidade (código extraído — MESMA semântica
+        // de desempate da v0.6.0, compartilhada com fwd_vetorizado)
+        let (designacao, carga) = selecionar_com_capacidade(
+            &probs,
+            &do_papel,
+            n,
+            self.n_top,
+            self.capacidade,
+            self.especialistas.len(),
+        );
+        let usados: Vec<usize> = designacao.iter().map(|(ei, _)| *ei).collect();
+        for (ei, escolhidos) in designacao {
             let idx: Vec<u32> = escolhidos.iter().map(|&i| i as u32).collect();
             let n_e = idx.len();
             let idx_t = Tensor::from_vec(idx, (n_e,), &dev)?;
@@ -316,6 +306,91 @@ impl MoeRedirecionavel {
         Ok(SaidaMoeR { saida, perda_aux, carga, descartados, usados })
     }
 
+    /// **M-R6 (v0.8.0):** passada VETORIZADA — roteamento, acúmulo e perda
+    /// auxiliar em OPERAÇÕES DE TENSOR rastreadas (proposta Qwen-3.8 nº 4
+    /// IMPLEMENTADA de verdade: o esboço original terminava em
+    /// `unimplemented!()`; a fórmula da perda auxiliar `E·Σ f_e·p̄_e`
+    /// estava CORRETA — Switch Transformer — e é mantida).
+    ///
+    /// **Correção do bug v080-1:** a acumulação usa `index_add` (op
+    /// rastreada pelo autograd do candle — `IndexAdd` em op.rs) em vez do
+    /// round-trip `to_vec2`/`from_vec`; os pesos de roteamento saem do
+    /// PRÓPRIO tensor `probs` (vivo até o roteador); a perda auxiliar usa
+    /// `p̄` do tensor vivo com `f` constante (padrão Switch: argmax é
+    /// não-diferenciável, a média de probs carrega o gradiente). O
+    /// gradiente flui por TODOS os caminhos (teste M-R7) com VALORES
+    /// idênticos aos da `fwd` (mesma seleção — teste M-R6).
+    pub fn fwd_vetorizado(&self, x: &Tensor, papel: Papel) -> Result<SaidaMoeR> {
+        let y = self.atencao.fwd(x)?; // (n, d)
+        let n = y.dim(0)?;
+        let d = y.dim(1)?;
+        let dev = y.device();
+        let e_total = self.especialistas.len();
+        let do_papel = self.indices_do_papel(papel);
+        let e_local = do_papel.len();
+        // 1) máscara do papel + softmax EM TENSOR — grafo VIVO até o roteador
+        let mut mascara_v = vec![f32::NEG_INFINITY; e_total];
+        for &e in &do_papel {
+            mascara_v[e] = 0.0;
+        }
+        let mascara = Tensor::from_vec(mascara_v, (1, e_total), &dev)?;
+        let logits = self.roteador.fwd(&y)?;
+        let mascarados = logits.broadcast_add(&mascara)?;
+        let probs = candle_nn::ops::softmax(&mascarados, candle_core::D::Minus1)?; // (n, E) VIVO
+        // 2) seleção discreta (única materialização — o roteamento duro é
+        // não-diferenciável por natureza; os PESOS ficam vivos no passo 3)
+        let probs_v = probs.to_vec2::<f32>()?;
+        let (designacao, carga) =
+            selecionar_com_capacidade(&probs_v, &do_papel, n, self.n_top, self.capacidade, e_total);
+        let usados: Vec<usize> = designacao.iter().map(|(ei, _)| *ei).collect();
+        // 3) acúmulo VIVO: index_add é rastreada — especialistas recebem
+        // gradiente pelas contribuições, e o roteador pelos pesos w
+        let mut saida = Tensor::zeros((n, d), candle_core::DType::F32, &dev)?;
+        let mut peso_total = Tensor::zeros((n, 1), candle_core::DType::F32, &dev)?;
+        for (ei, escolhidos) in &designacao {
+            let idx: Vec<u32> = escolhidos.iter().map(|&i| i as u32).collect();
+            let n_e = idx.len();
+            let idx_t = Tensor::from_vec(idx, (n_e,), &dev)?;
+            let tile = y.index_select(&idx_t, 0)?; // VIVO
+            let y_e = self.especialistas[*ei].fwd(&tile)?; // VIVO (gradiente!)
+            // w = probs[i][ei] VIVO: gradiente flui ao roteador
+            let linhas = probs.index_select(&idx_t, 0)?; // (n_e, E) VIVO
+            let w_t = linhas.narrow(1, *ei, 1)?.contiguous()?; // (n_e, 1) VIVO
+            let contrib = y_e.broadcast_mul(&w_t)?; // (n_e, d) VIVO
+            saida = saida.index_add(&idx_t, &contrib, 0)?; // VIVO (M-R6)
+            peso_total = peso_total.index_add(&idx_t, &w_t, 0)?; // VIVO
+        }
+        // 4) normalização idêntica à fwd (clamp 1e-6 nos descartados)
+        let pt_v = peso_total.to_vec2::<f32>()?; // estatística apenas
+        let mut descartados = 0usize;
+        for i in 0..n {
+            if pt_v[i][0] == 0.0 {
+                descartados += 1;
+            }
+        }
+        let denom = peso_total.clamp(1e-6, f64::INFINITY)?;
+        let saida = saida.broadcast_div(&denom)?;
+        let saida = (&y + &saida)?; // residual — como a fwd
+        // 5) perda auxiliar EM TENSOR (fórmula M-R1/Switch: e_local·Σ f_e·p̄_e)
+        let cols: Vec<u32> = do_papel.iter().map(|&e| e as u32).collect();
+        let cols_t = Tensor::from_vec(cols, (e_local.max(1),), &dev)?;
+        let probs_local = probs.index_select(&cols_t, 1)?; // (n, e_local) VIVO
+        let argmax_v = probs_local.argmax(candle_core::D::Minus1)?.to_vec1::<u32>()?;
+        let mut f = vec![0f32; e_local.max(1)];
+        for &a in &argmax_v {
+            f[a as usize] += 1.0;
+        }
+        if n > 0 {
+            for v in f.iter_mut() {
+                *v /= n as f32;
+            }
+        }
+        let f_t = Tensor::from_vec(f, (e_local.max(1),), &dev)?;
+        let p_barra = probs_local.mean_keepdim(0)?.flatten_all()?; // (e_local,) VIVO
+        let perda_aux = ((&f_t * &p_barra)?.sum_all()? * (e_local.max(1) as f64))?;
+        Ok(SaidaMoeR { saida, perda_aux, carga, descartados, usados })
+    }
+
     /// **M-R3:** passadas Codificador e Decodificador em DUAS THREADS
     /// (DAGs independentes — especialistas disjuntos por papel). Devolve
     /// (enc, dec, tempo_paralelo_s, tempo_sequencial_s, speedup).
@@ -354,6 +429,49 @@ impl MoeRedirecionavel {
 // M-R5 — alocação water-filling por QE
 // ---------------------------------------------------------------------------
 
+/// Seleção top-k com capacidade por especialista (v0.8.0 — extraída
+/// VERBATIM do loop da `fwd` v0.6.0: mesma ordem de candidatos, mesmos
+/// desempates estáveis de `sort_by`). Compartilhada por `fwd` e
+/// `fwd_vetorizado` ⇒ as duas atribuem EXATAMENTE os mesmos tokens aos
+/// mesmos especialistas (base do teste M-R6 — equivalência de valores).
+/// Devolve (designação por especialista, carga global por especialista).
+fn selecionar_com_capacidade(
+    probs: &[Vec<f32>],
+    do_papel: &[usize],
+    n: usize,
+    n_top: usize,
+    capacidade: usize,
+    n_especialistas: usize,
+) -> (Vec<(usize, Vec<usize>)>, Vec<usize>) {
+    let mut carga = vec![0usize; n_especialistas];
+    let mut designacao: Vec<(usize, Vec<usize>)> = Vec::new();
+    for &ei in do_papel.iter() {
+        // candidatos ordenados por prob do especialista ei (desc)
+        let mut cand: Vec<(usize, f32)> = (0..n).map(|i| (i, probs[i][ei])).collect();
+        cand.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+        let mut escolhidos: Vec<usize> = Vec::new();
+        for (i, _) in cand {
+            if carga[ei] >= capacidade {
+                break;
+            }
+            // ei está no top-k(papel) do token i?
+            let mut ordem: Vec<(f32, usize)> =
+                do_papel.iter().map(|&g| (probs[i][g], g)).collect();
+            ordem.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap());
+            let top: Vec<usize> = ordem.iter().rev().take(n_top).map(|(_, g)| *g).collect();
+            if top.contains(&ei) {
+                escolhidos.push(i);
+                carga[ei] += 1;
+            }
+        }
+        if escolhidos.is_empty() {
+            continue;
+        }
+        designacao.push((ei, escolhidos));
+    }
+    (designacao, carga)
+}
+
 /// Aloca `capacidade_total` especialistas entre células com QE `qes`
 /// proporcionalmente ao QE (Cauchy–Schwarz: minimiza Σ q_i²/c_i).
 /// Devolve c_i ≥ 1 com Σ c_i = capacidade_total (se capacidade ≥ células).
@@ -486,8 +604,10 @@ pub fn treinar_jepa_com_moe(
                     z.sqr()?.mean_all()?, 0))
             }
             Braco::Moe(m) => {
-                let s_enc = m.fwd(x, Papel::Codificador)?;
-                let s_dec = m.fwd(&s_enc.saida, Papel::Decodificador)?;
+                // v0.8.0 (bug v080-1): fwd_vetorizado — gradiente flui aos
+                // especialistas e ao roteador (a fwd seccionava o grafo)
+                let s_enc = m.fwd_vetorizado(x, Papel::Codificador)?;
+                let s_dec = m.fwd_vetorizado(&s_enc.saida, Papel::Decodificador)?;
                 let dif = (&s_dec.saida - &alvo)?;
                 let lp = (dif.sqr()?.sum_all()? / (n as f64 * d as f64))?;
                 // perda total = preditiva + aux balanceamento (ambos papéis)
@@ -559,7 +679,7 @@ pub fn treinar_jepa_com_moe(
         };
     }
     if let Braco::Moe(m) = &braco {
-        let s = m.fwd(&contexto, Papel::Codificador)?;
+        let s = m.fwd_vetorizado(&contexto, Papel::Codificador)?;
         descartados = s.descartados;
     }
     Ok(RelatorioJepaMoe {
@@ -933,6 +1053,131 @@ mod testes {
         let r = treinar_jepa_com_moe(&x, "moe", 60, 0.5, 42).unwrap();
         assert!(r.perda_pred_final < r.perda_pred_inicial, "perda preditiva cai");
     }
+
+    /// **M-R6 (v0.8.0):** equivalência de VALORES entre `fwd` e
+    /// `fwd_vetorizado` — mesma seleção (auxiliar compartilhado), mesma
+    /// saída, mesma perda auxiliar, mesma carga/descartados.
+    #[test]
+    fn mr6_equivalencia_de_valores() {
+        let dev = Device::Cpu;
+        for (n, d, e, k, cap, seed) in [
+            (64usize, 16usize, 6usize, 2usize, 64usize, 3u64),
+            (96, 24, 8, 2, 96, 5),
+            (48, 12, 4, 1, 24, 9), // capacidade apertada: força descartados
+        ] {
+            let x = dados_sinteticos(n, d, seed);
+            let moe = MoeRedirecionavel::novo(d, e, k, cap, &dev).unwrap();
+            let s_ref = moe.fwd(&x, Papel::Codificador).unwrap();
+            let s_vet = moe.fwd_vetorizado(&x, Papel::Codificador).unwrap();
+            assert_eq!(s_ref.carga, s_vet.carga, "M-R6: mesma carga (n={n})");
+            assert_eq!(s_ref.usados, s_vet.usados, "M-R6: mesmos usados");
+            assert_eq!(s_ref.descartados, s_vet.descartados, "M-R6: mesmos descartados");
+            let dif = (&s_ref.saida - &s_vet.saida).unwrap()
+                .abs().unwrap().max_all().unwrap().to_scalar::<f32>().unwrap();
+            assert!(dif < 1e-4, "M-R6: max|Δsaída| = {dif} (n={n}, cap={cap})");
+            let pa = s_ref.perda_aux.to_scalar::<f32>().unwrap();
+            let pb = s_vet.perda_aux.to_scalar::<f32>().unwrap();
+            assert!(
+                (pa - pb).abs() < 1e-4,
+                "M-R6: perda auxiliar {pa:.6} vs {pb:.6} (n={n})"
+            );
+        }
+    }
+
+    /// **M-R7 (v0.8.0):** restauração do fluxo de gradiente — bug v080-1.
+    /// Com a `fwd` (referência de valores) os especialistas e o roteador
+    /// NÃO recebem gradiente (grafo seccionado por to_vec2/from_vec); com
+    /// a `fwd_vetorizado` TODOS recebem (index_add/index_select vivos).
+    #[test]
+    fn mr7_restauracao_do_gradiente() {
+        let dev = Device::Cpu;
+        let x = dados_sinteticos(48, 12, 13);
+        let moe = MoeRedirecionavel::novo(12, 6, 2, 48, &dev).unwrap();
+        let norma_grads = |vetorizada: bool| -> (f64, f64) {
+            let s = if vetorizada {
+                moe.fwd_vetorizado(&x, Papel::Codificador).unwrap()
+            } else {
+                moe.fwd(&x, Papel::Codificador).unwrap()
+            };
+            let perda = s.saida.sqr().unwrap().sum_all().unwrap();
+            let grads = perda.backward().unwrap();
+            let mut n_roteador = 0.0f64;
+            for v in moe.roteador.vars() {
+                if let Some(g) = grads.get(&v) {
+                    n_roteador += g.sqr().unwrap().sum_all().unwrap()
+                        .to_scalar::<f32>().unwrap() as f64;
+                }
+            }
+            let mut n_experts = 0.0f64;
+            for e in &moe.especialistas {
+                for v in e.vars() {
+                    if let Some(g) = grads.get(&v) {
+                        n_experts += g.sqr().unwrap().sum_all().unwrap()
+                            .to_scalar::<f32>().unwrap() as f64;
+                    }
+                }
+            }
+            (n_roteador, n_experts)
+        };
+        // (a) o bug v080-1 é REAL: na fwd, roteador e especialistas têm
+        // gradiente ZERO (grafo seccionado) — documentado, não corrigido na
+        // fwd (referência de valores preservada por decisão de projeto)
+        let (r_ref, e_ref) = norma_grads(false);
+        assert!(
+            r_ref == 0.0 && e_ref == 0.0,
+            "M-R7: bug v080-1 documentado — fwd secciona o grafo (roteador {r_ref}, experts {e_ref})"
+        );
+        // (b) a correção: na vetorizada, TODOS recebem gradiente
+        let (r_vet, e_vet) = norma_grads(true);
+        assert!(
+            r_vet > 0.0,
+            "M-R7: roteador recebe gradiente na vetorizada ({r_vet})"
+        );
+        assert!(
+            e_vet > 0.0,
+            "M-R7: especialistas recebem gradiente na vetorizada ({e_vet})"
+        );
+    }
+
+    /// **M-R8 (v0.8.0):** fim-a-fim — com a vetorizada, o treino REALMENTE
+    /// atualiza os pesos dos especialistas (regressão do bug v080-1: antes
+    /// só a atenção própria treinava no braço MoE).
+    #[test]
+    fn mr8_treino_atualiza_especialistas() {
+        let dev = Device::Cpu;
+        let x = dados_sinteticos(48, 12, 17);
+        let moe = MoeRedirecionavel::novo(12, 6, 2, 48, &dev).unwrap();
+        // snapshot com dados PRÓPRIOS (to_vec1) — detach() compartilha o
+        // storage e o set() do otimizador sobrescreveria a "cópia"
+        let snapshot: Vec<Vec<f32>> = moe
+            .especialistas
+            .iter()
+            .map(|e| {
+                e.vars()[0].as_tensor().flatten_all().unwrap().to_vec1::<f32>().unwrap()
+            })
+            .collect();
+        // treino curto com gradiente fluindo
+        let vars = moe.vars();
+        let mut opt = crate::treino::AdamWManual::novo(vars.clone(), 3e-3, 0.0);
+        for _ in 0..5 {
+            let s = moe.fwd_vetorizado(&x, Papel::Codificador).unwrap();
+            let perda = s.saida.sqr().unwrap().sum_all().unwrap();
+            let grads = crate::treino::grads_achatados(&perda, &vars).unwrap();
+            opt.passo(grads);
+        }
+        let mut delta_max = 0.0f64;
+        for (e, antes) in moe.especialistas.iter().zip(snapshot.iter()) {
+            let agora = e.vars()[0].as_tensor().flatten_all().unwrap()
+                .to_vec1::<f32>().unwrap();
+            let dif = agora.iter().zip(antes.iter()).map(|(a, b)| (a - b).abs()).fold(0f32, f32::max);
+            delta_max = delta_max.max(dif as f64);
+        }
+        let _ = &vars;
+        assert!(
+            delta_max > 0.0,
+            "M-R8: especialistas devem mudar no treino (delta_max={delta_max})"
+        );
+    }
 }
 
 #[cfg(test)]

src/quantizador.rs

@@ -67,7 +67,11 @@ impl CustomOp3 for GsqSuave {
         let c = _s2.as_slice::<f32>()?;
         let (k, _dc) = (_l2.shape().dims()[0], _l2.shape().dims()[1]);
         let ruido = s3.as_slice::<f32>()?;
-        debug_assert_eq!(ruido.len(), z.len() / d * k * d / d * k); // (n,k)
+        // v0.8.0 (bug v080-2, pré-existente): a fórmula anterior
+        // `z.len()/d*k*d/d*k` avaliava para n·k²·(…) sem sentido (320 ≠ 40
+        // no teste) e disparava em TODO build debug — os gates da v0.7.0 só
+        // passavam em release (debug_assert compilado fora). Correta: n·k.
+        debug_assert_eq!(ruido.len(), n * k); // (n, k)
         // logits = z·Cᵀ/τ + g
         let mut logits = vec![0f32; n * k];
         for i in 0..n {

src/verificador.rs

@@ -94,6 +94,115 @@ pub fn calibrar_temperatura(logits: &Tensor, alvos: &Tensor) -> Result<(f64, f64
     Ok((t_estrela, nll_1, nll_estrela))
 }
 
+/// Derivadas analíticas da NLL de temperatura — base do Newton-Raphson
+/// (proposta Qwen-3.8 nº 1, **CORRIGIDA**: o original inverteu o sinal de
+/// dL/dT — `(E_p[z] − z_y)/T²` em vez de `(z_y − E_p[z])/T²` — e usou a
+/// primeira diferença `[L(T+ε)−L(T)]/ε` como se fosse a SEGUNDA derivada;
+/// com os dois erros combinados o passo Δ ≈ −1 empurra T para cima a cada
+/// iteração até o clamp — errata completa em r-33 §2). Com p = softmax(z/T):
+/// `L(T)  = média_i [−z_{i,y_i}/T + log Σ_j e^{z_{i,j}/T}]`
+/// `L'(T) = média_i ( z_{i,y_i} − E_{p_i}[z_i] ) / T²`
+/// `L''(T)= média_i ( Var_{p_i}(z_i) − 2T·(z_{i,y_i} − E_{p_i}[z_i]) ) / T⁴`
+/// (Teo N-1 — derivação direta; no ótimo L'(T*)=0 ⇒ L''(T*) = Var/T⁴ > 0.)
+fn grad_hess_temperatura(logits: &Tensor, alvos: &Tensor, t: f64) -> Result<(f64, f64, f64)> {
+    let n = logits.dim(0)?;
+    let escalado = logits.affine(1.0 / t, 0.0)?;
+    let ce = candle_nn::loss::cross_entropy(&escalado, alvos)?;
+    let l = ce.to_scalar::<f32>()? as f64;
+    let p = candle_nn::ops::softmax(&escalado, candle_core::D::Minus1)?;
+    // E_p[z] e E_p[z²] por linha — Var_p(z) = E[z²] − (E[z])² em UMA passada
+    let ez = (&p * logits)?.sum_keepdim(candle_core::D::Minus1)?;
+    let ez2 = (&p * &logits.sqr()?)?.sum_keepdim(candle_core::D::Minus1)?;
+    let var = (&ez2 - &(&ez * &ez)?)?;
+    // z_y por linha via gather
+    let idx = alvos.reshape((n, 1))?;
+    let zt = logits.gather(&idx, candle_core::D::Minus1)?;
+    let ez_m = ez.mean_all()?.to_scalar::<f32>()? as f64;
+    let var_m = var.mean_all()?.to_scalar::<f32>()? as f64;
+    let zt_m = zt.mean_all()?.to_scalar::<f32>()? as f64;
+    let dif = zt_m - ez_m;
+    let t2 = t * t;
+    let dl = dif / t2;
+    let d2l = (var_m - 2.0 * t * dif) / (t2 * t2);
+    Ok((l, dl, d2l))
+}
+
+/// **N-4:** calibra T* por **Newton-Raphson com derivadas analíticas**
+/// (convergência quadrática — Teo N-3) e **salvaguarda de bisseção
+/// geométrica** sobre o sinal de L̃'. A iteração é feita em **γ = 1/T**:
+/// L̃(γ) = NLL(softmax(γz)) é CONVEXA (N-2: L̃''(γ) = Var_p(z) ≥ 0
+/// SEMPRE — não apenas perto do ótimo), com
+/// `L̃'(γ) = E_p[z] − z_y` e `L̃''(γ) = Var_p(z)` — o Newton em γ nunca
+/// encontra curvatura negativa e o colchão γ ∈ [1/8, 8] (⇔ T ∈ [1/8, 8],
+/// o mesmo da V-1) é mantido como invariante com a bisseção de salvaguarda.
+/// Pior caso: bisseção pura, ⌈log₂(ln 64/ε)⌉ ≈ 35 passos; típico: 4–12
+/// avaliações (vs ~44 do golden-section). Devolve (T*, nll(1), nll(T*), n_aval).
+pub fn calibrar_temperatura_newton(
+    logits: &Tensor,
+    alvos: &Tensor,
+    max_iters: usize,
+) -> Result<(f64, f64, f64, usize)> {
+    let nll_em = |t: f64| nll_temperatura(logits, alvos, t);
+    let nll_1 = nll_em(1.0)?;
+    // (L, L̃'(γ), L̃''(γ)) com escalado = γ·z (p = softmax(γz)):
+    // L̃' = média(E_p[z] − z_y); L̃'' = média(Var_p(z)) ≥ 0 (N-2)
+    let gh_gamma = |g: f64| -> Result<(f64, f64, f64)> {
+        let n = logits.dim(0)?;
+        let escalado = logits.affine(g, 0.0)?;
+        let ce = candle_nn::loss::cross_entropy(&escalado, alvos)?;
+        let l = ce.to_scalar::<f32>()? as f64;
+        let p = candle_nn::ops::softmax(&escalado, candle_core::D::Minus1)?;
+        let ez = (&p * logits)?.sum_keepdim(candle_core::D::Minus1)?;
+        let ez2 = (&p * &logits.sqr()?)?.sum_keepdim(candle_core::D::Minus1)?;
+        let var = (&ez2 - &(&ez * &ez)?)?;
+        let idx = alvos.reshape((n, 1))?;
+        let zt = logits.gather(&idx, candle_core::D::Minus1)?;
+        let ez_m = ez.mean_all()?.to_scalar::<f32>()? as f64;
+        let var_m = var.mean_all()?.to_scalar::<f32>()? as f64;
+        let zt_m = zt.mean_all()?.to_scalar::<f32>()? as f64;
+        Ok((l, ez_m - zt_m, var_m))
+    };
+    let (lo, hi) = (1.0f64 / 8.0, 8.0f64); // colchão em γ ⇔ T ∈ [1/8, 8]
+    // mínimo na borda? (convexa: L̃' não troca sinal dentro do colchão)
+    let (_, dlo, _) = gh_gamma(lo)?;
+    if dlo >= 0.0 {
+        // mínimo em γ=lo ⇒ T* = 8 (esfriar ao máximo)
+        return Ok((1.0 / lo, nll_1, nll_em(1.0 / lo)?, 1));
+    }
+    let (_, dhi, _) = gh_gamma(hi)?;
+    if dhi <= 0.0 {
+        // mínimo em γ=hi ⇒ T* = 1/8 (aquecer ao máximo)
+        return Ok((1.0 / hi, nll_1, nll_em(1.0 / hi)?, 1));
+    }
+    // invariante do colchão: L̃'(a) < 0 < L̃'(b) (L̃ convexa ⇒ válida)
+    let (mut a, mut b) = (lo, hi);
+    let mut g = 1.0f64; // chute inicial γ=1 (T=1, incalibrado)
+    let mut melhor = (1.0f64, nll_1); // (T, NLL)
+    let mut n_aval = 2usize;
+    for _ in 0..max_iters {
+        let (l, dp, d2p) = gh_gamma(g)?;
+        n_aval += 1;
+        let t = 1.0 / g;
+        if l < melhor.1 {
+            melhor = (t, l);
+        }
+        if dp.abs() < 1e-10 || (b - a) < 1e-12 {
+            break;
+        }
+        // atualiza o colchão pelo sinal de L̃' (bisseção válida — N-2)
+        if dp < 0.0 {
+            a = a.max(g);
+        } else {
+            b = b.min(g);
+        }
+        // Newton em γ: L̃'' = Var ≥ 0 SEMPRE (convexidade global);
+        // passo aceito só DENTRO do colchão, senão bisseção geométrica
+        let gn = if d2p > 1e-12 { g - dp / d2p } else { f64::NAN };
+        g = if gn.is_finite() && gn > a && gn < b { gn } else { (a * b).sqrt() };
+    }
+    Ok((melhor.0, nll_1, melhor.1, n_aval))
+}
+
 /// ECE (Expected Calibration Error) por faixas de confiança.
 pub fn ece(confs: &[f64], corretos: &[bool], n_faixas: usize) -> f64 {
     if confs.is_empty() || confs.len() != corretos.len() {
@@ -150,8 +259,23 @@ impl VerificadorNcm {
     }
 
     /// Ajusta T* em (logits, alvos) retidos e mede o ECE antes/depois.
+    /// v0.8.0: Newton-Raphson analítico (N-4) com salvaguarda — o
+    /// golden-section (V-1) permanece como verificação/rede de segurança.
     pub fn ajustar(&mut self, logits: &Tensor, alvos: &Tensor) -> Result<(f64, f64)> {
-        let (t, nll1, nllt) = calibrar_temperatura(logits, alvos)?;
+        let (mut t, mut nll1, mut nllt) = (1.0, 0.0, 0.0);
+        let mut ok = false;
+        // Newton com salvaguarda (4× o orçamento típico de avaliações)
+        if let Ok((tn, n1, nt, _)) = calibrar_temperatura_newton(logits, alvos, 40) {
+            if nt.is_finite() && nt <= n1 + 1e-6 {
+                (t, nll1, nllt) = (tn, n1, nt);
+                ok = true;
+            }
+        }
+        if !ok {
+            // rede de segurança: golden-section (V-1) — nunca removida
+            let (tg, n1g, ntg) = calibrar_temperatura(logits, alvos)?;
+            (t, nll1, nllt) = (tg, n1g, ntg);
+        }
         self.temperatura = t;
         self.n_ll_antes = nll1;
         self.n_ll_depois = nllt;
@@ -289,4 +413,138 @@ mod testes {
             .to_scalar::<f32>().unwrap();
         assert!(d == 0.0, "determinístico nos logits do presente");
     }
+
+    /// **N-1:** gradiente/curvatura analíticos batem com diferenças finitas
+    /// centralmente — validação numérica da derivação do Teo N-1 (e errata
+    /// da proposta Qwen-3.8 nº 1: sinal de L' e ordem da diferença finita).
+    #[test]
+    fn n1_grad_hess_analiticos_vs_finitas() {
+        let (lt, at) = logits_sinteticos(512, 16, 2.0, 23);
+        let t = 1.3f64;
+        let (_, dl, d2l) = grad_hess_temperatura(&lt, &at, t).unwrap();
+        let h = 1e-2; // f32: equilíbrio ruído/truncamento (r-33 §2.4)
+        let l_mais = nll_temperatura(&lt, &at, t + h).unwrap();
+        let l_zero = nll_temperatura(&lt, &at, t).unwrap();
+        let l_menos = nll_temperatura(&lt, &at, t - h).unwrap();
+        let dl_fd = (l_mais - l_menos) / (2.0 * h);
+        // SEGUNDA diferença (a proposta original usava a PRIMEIRA)
+        let d2l_fd = (l_mais - 2.0 * l_zero + l_menos) / (h * h);
+        assert!(
+            (dl - dl_fd).abs() < 5e-3,
+            "N-1: L' analítico {dl:.6} vs finita {dl_fd:.6}"
+        );
+        assert!(
+            (d2l - d2l_fd).abs() < 5e-2,
+            "N-1: L'' analítico {d2l:.6} vs finita {d2l_fd:.6}"
+        );
+        // REGRESSÃO DA ERRATA: superconfiante (escala 2) ⇒ T* > 1 ⇒ L'(T=1)
+        // deve ser NEGATIVO (L desce em direção a T*). O sinal invertido da
+        // proposta daria positivo — e o Newton divergiria para o clamp 10.
+        let (_, dl_em_1, _) = grad_hess_temperatura(&lt, &at, 1.0).unwrap();
+        assert!(dl_em_1 < 0.0, "N-1: L'(1)={dl_em_1} deve ser < 0 (superconfiante)");
+    }
+
+    /// **N-2/N-4:** Newton com salvaguarda encontra o MESMO T* do
+    /// golden-section (V-1) com MENOS avaliações de NLL.
+    #[test]
+    fn n2_newton_igual_golden_mais_rapido() {
+        for (escala, semente) in [(1.0f32, 31u64), (3.0, 37), (0.3, 41)] {
+            let (lt, at) = logits_sinteticos(1024, 32, escala, semente);
+            let (t_g, _, nll_g) = calibrar_temperatura(&lt, &at).unwrap();
+            let (t_n, nll_1, nll_n, n_aval) =
+                calibrar_temperatura_newton(&lt, &at, 40).unwrap();
+            assert!(
+                (t_g - t_n).abs() < 1e-3,
+                "N-2: T* golden {t_g:.6} vs newton {t_n:.6} (escala {escala})"
+            );
+            assert!(
+                nll_n <= nll_g + 1e-4,
+                "N-4: NLL newton {nll_n:.6} ≤ golden {nll_g:.6} + 1e-4"
+            );
+            assert!(
+                nll_n <= nll_1 + 1e-6,
+                "N-4: NLL calibrada {nll_n:.6} ≤ bruta {nll_1:.6}"
+            );
+            // golden ~44 avaliações típicas (66 no teto); Newton ≤ 36
+            assert!(
+                n_aval < 36,
+                "N-4: newton usou {n_aval} avaliações (esperado < 36)"
+            );
+        }
+    }
+
+    /// **N-2 (verificação do teorema):** L' troca o sinal EXATAMENTE uma
+    /// vez no colchão (unimodalidade — NLL convexa em γ = 1/T).
+    #[test]
+    fn n3_sinal_de_l_troca_uma_vez() {
+        let (lt, at) = logits_sinteticos(2048, 16, 2.5, 43);
+        let mut trocas = 0usize;
+        let mut sinal_ant: Option<f64> = None;
+        for i in 0..64 {
+            let t = ((i as f64 / 63.0 * (8.0f64.ln() - (1.0f64 / 8.0).ln()))
+                + (1.0f64 / 8.0).ln())
+                .exp();
+            let (_, dl, _) = grad_hess_temperatura(&lt, &at, t).unwrap();
+            let s: f64 = if dl < 0.0 { -1.0 } else { 1.0 };
+            if let Some(sa) = sinal_ant {
+                if s != sa {
+                    trocas += 1;
+                }
+            }
+            sinal_ant = Some(s);
+        }
+        assert_eq!(trocas, 1, "N-2: L' deve trocar o sinal exatamente 1 vez (trocas={trocas})");
+    }
+
+    /// **N-4 (casos extremos):** direção correta da calibração nos dois
+    /// regimes — superconfiante (ERROS confiantes: margem alta com ruído
+    /// moderado ⇒ L̃'(1) = média(E_p[z] − z_y) > 0 ⇒ γ* < 1 ⇒ T* > 1,
+    /// esfria) e subconfiante (margem modesta com ruído mínimo: corretos
+    /// dominam com p_y < 1 ⇒ T* < 1, aquece). Nota: a contribuição de cada
+    /// exemplo para L̃' é Σ_{j≠y} p_j(z_j − z_y) ≤ 0 para acertos e ≫ 0
+    /// para erros confiantes — é por isso que a NLL "escuta" os erros.
+    #[test]
+    fn n4b_casos_extremos() {
+        let dev = Device::Cpu;
+        // (a) superconfiante (padrão de overfitting): 95% acertos com
+        // margem 5,4 (p_y ≈ 0,97) e 5% ERROS confiantes com margem 8,4
+        // (p_errado ≈ 1) ⇒ conf ≈ 0,97 > acc = 0,95 ⇒ T* > 1. A
+        // contribuição dos erros para L̃'(1) é ≈ +8,4·0,05 = +0,42 vs
+        // −0,15 dos acertos ⇒ L̃'(1) > 0 ⇒ γ* < 1 ⇒ T* > 1 (esfria).
+        let mut rng = crate::rng::RngDeterministico::novo(47);
+        let (n, k) = (2048usize, 8usize);
+        let mut l = Vec::with_capacity(n * k);
+        let mut a = Vec::with_capacity(n);
+        for _ in 0..n {
+            let alvo = rng.inteiro(k) as u32;
+            a.push(alvo);
+            if rng.uniforme() < 0.05 {
+                let mut w = rng.inteiro(k) as u32;
+                if w == alvo {
+                    w = (w + 1) % k as u32;
+                }
+                for j in 0..k {
+                    l.push(if j as u32 == w { 8.4 } else { 0.0 });
+                }
+            } else {
+                for j in 0..k {
+                    let base = if j as u32 == alvo { 5.4 } else { 0.0 };
+                    l.push(base + rng.normal(0.0, 0.25) as f32);
+                }
+            }
+        }
+        let lt = Tensor::from_vec(l, (n, k), &dev).unwrap();
+        let at = Tensor::from_vec(a, (n,), &dev).unwrap();
+        let (t_n, nll_1, nll_n, _) = calibrar_temperatura_newton(&lt, &at, 40).unwrap();
+        assert!(t_n > 1.0, "N-4b: superconfiante exige T*>1 (T*={t_n})");
+        assert!(nll_n <= nll_1 + 1e-6);
+        assert!((1.0 / 8.0..=8.0).contains(&t_n), "N-4b: T* dentro do colchão");
+        // (b) subconfiante: margem 3 com ruído mínimo ⇒ p_y ≈ 0,74 < acc
+        // ≈ 1 ⇒ T* < 1 (aquece; medido na borda quente 1/8)
+        let (lt2, at2) = logits_sinteticos(512, 8, 0.1, 53);
+        let (t_n2, nll_12, nll_n2, _) = calibrar_temperatura_newton(&lt2, &at2, 40).unwrap();
+        assert!(t_n2 < 1.0, "N-4b: subconfiante exige T*<1 (T*={t_n2})");
+        assert!(nll_n2 <= nll_12 + 1e-6, "N-4b: NLL não piora");
+        assert!((1.0 / 8.0..=8.0).contains(&t_n2));
+    }
 }