# KHTST — Análise Matemática, Defeitos Provados e Aprimoramentos JEPA **Escopo:** todos os `*.py` e `*.pyx` de `src/khtst` (205 arquivos, ~18.332 linhas). Excluídos por instrução: `*.c` e `*.so`. **Método:** leitura integral do código + verificação numérica em PyTorch 2.14.1 (CPU). Toda afirmação marcada **[PROVADO]** foi executada; o script está em `verificacao/`. > **v15.1 — ATUALIZAÇÃO (implementação e verificação).** Os 6 defeitos > provados nas Seções 2–7 estão **CORRIGIDOS e VERIFICADOS** (49 verificações > em `patches/verificar_tudo.py`, 0 falhas, 3 execuções determinísticas; > 13 suítes do repo verdes; smoke de integração 13 ✓; teste com DADOS REAIS > aprovado). A auditoria da segunda ordem (corrigir as correções) achou **7 > novos defeitos na camada de patches** — provados e corrigidos na Seção 14. > Fonte única anti-divergência: `patches/correcoes.py` (verificação) ≡ > `src/khtst/quanta/gsq_rco.py` + `src/khtst/treino/jepa*.py` (produção), > comparados por SHA-256 a cada execução (o padrão do defeito 1 não pode > recorrer). --- ## 0. Sumário executivo O KHTST é um projeto sério. A densidade formal é real — há 29 documentos matemáticos, teoremas numerados, e a maior parte das provas que o README cita **passa na verificação**. O kernel Mamba-3 em `mamba3/kernel.py` está correto, a varredura trapezoidal é exata, o núcleo Cython `rco_gsq.pyx` tem correções de layout LAPACK genuinamente corretas (B2/B3 são bugs reais e foram bem diagnosticados), e a maior parte das Gates "nascem neutras" realmente nascem neutras. **Porém três coisas estão erradas**, e elas são exatamente as três que o README vende como as novidades: | # | Alegação | Realidade | Status v15.1 | |---|----------|-----------|--------------| | 1 | "EQUAÇÃO DE AUTOAJUSTE de λ_c" (novidade v15) | A equação está em **duas implementações que divergem**. O caminho rápido (Cython, usado no treino) **não implementa a equação** — degrada para uma constante. **[PROVADO: 4/6 espectros]** | ✅ CORRIGIDO — equação ÚNICA (`lambda_c_unica` ≡ `lambda_c_autoajustavel`), equivalência **206/206 espectros** | | 2 | Trade-off K (compressão × erro) | O termo de custo `b(K)=log₂K/log₂d` é **dimensionalmente incoerente**. O `argmin` resultante penaliza a dimensão `d`, que é justamente a variável que se quer manter. **[PROVADO]** | ✅ CORRIGIDO — custo rate–distortion explícito (índice + codebook k·d/n em bits); K* reage a d na direção certa (23→21→21 para d=64→512→4096) | | 3 | "Erro Topológico TE" como critério de ganho | O TE mede **geometria da grade**, não erro de representação. Não detecta falha de codificação. **[PROVADO por construção]** | ✅ CORRIGIDO — `te_quantizacao` (QE) + `te_consistencia_temporal` (deriva ponderada por ocupação), monotono na deriva | E há um **buraco arquitetural** que anula o requisito central do projeto: > **Não existe JEPA em lugar nenhum do pacote.** `grep -rniE "jepa|target_encoder|ema_target|predictor_latent"` sobre os 205 arquivos retorna **zero ocorrências**. Não há aprendizado de representação latente preditiva; há apenas CE sobre tokens. Sem encoder-alvo, o requisito de "aprender representations em vez de reconstruir" **não está implementado** — está apenas documentado como o que os outros fizeram. Além disso, a difusão **não "sonha"**: ela roda em `no_grad`, não produz gradiente, e não tem sinal de erro. Ela **registra**, não aprende. **Veredito:** a foundation matemática é sólida; os três pilaresNovelty precisam de reparo; e o JEPA + o motor de sonho propostos nas Seções 4–7 são o que falta para o projeto cumprir o próprio requisito. --- ## 1. O que está correto (e merece ser preservado) Antes dos defeitos, o que passou: **1.1 — Mamba-3 (`mamba3/kernel.py:60-88`).** A recorrência trapezoidal `h_t = α_t·h_{t-1} + (δ_t/2)(1+α_t)·b̄_t·u_t` com `α_t = exp(δ_t·A)` e `δ=σ(·)∈(0,1)`, `A<0` é matematicamente boa: `α ∈ (e^A, 1) ⊂ (0,1)` garante **contração**, e a recursão é exata em autograd (não aproximada). O `devolve_estado=True` devolve `h_L` que é *exatamente* o estado do decode incremental — a propriedade de composição `varredura(u_1..L) ⊕ passo(u_{L+1}) ≡ varredura(u_1..L+1)` é verdadeira e útil. A agregação MIMO `b̄_t,n = Σ_r B[t,r,n]` antes do laço é uma otimização legítima (economia O(B·L·D·N·R) → O(B·L·D·N)). **1.2 — `rco_gsq.pyx`, correções B2/B3.** O diagnóstico de que LAPACK é column-major e que o rascunho passava memória C-order (interpretada como transposta) é **exato** e é um bug da classe mais silenciosa que existe. A query de `lwork` e a checagem de `info` são as práticas corretas. A remoção de `-ffast-math` está fundamentada: as provas de `‖QᵀQ−I‖ = O(ε)` exigem IEEE-754 estrito. **1.3 — Portas de nascimento neutro.** A convenção `γ=0`, `ρ=0`, `α=0`, `β=0` para que a v15 reproduza exatamente a v14 é matematicamente bem pensada: garante não-regressão por construção. Verifiquei que `RoteadorAtencaoMoE.gamma` nasce em zeros e `d(γ·s_atn)/dγ = s_atn ≠ 0` — a condição para aprender está correta. **1.4 — VQ-EMA com dead-code por janela** (`memoria/interna.py:73-79`). Corrigir a contagem *acumulada* para *EMA* foi o conserto certo: contagem acumulada nunca "perdoa" um código que ficou morto no passado, e força reativa constante. **1.5 — `AgendadorTau` / barreira `τ_min ≥ 1/(2τ)`** e a condição de afiamento `P ≥ 1−e^{−Δ₂/τ}` estão com a derivação certa. --- ## 2. Defeito 1 — A "equação de autoajuste de λ_c" diverge entre Cython e Python **[PROVADO]** ### 2.1 O achado A mesma fórmula é implementada em dois lugares: - `acelerado/criterios.pyx:47` → `knee_lambda_c` - `quanta/gsq_rco.py:842` → `lambda_c_autoajustavel` A fórmula de ambas é a mesma e está **correta**: ``` J_λ(j) − J_λ(i) = λ·Δb(i,j) − (1−λ)·Δε²(i,j), i < j J_λ(j) ≤ J_λ(i) ⟺ λ ≤ φ(i,j) := Δε²(i,j) / (Δε²(i,j) + Δb(i,j)) ``` Verifiquei numericamente que `φ ∈ (0,1)`, que `K*(λ)` é não-crescente em `λ`, que `K*(0⁺)=d`, `K*(1⁻)=1`, e que o intervalo `[λ_lo, λ_hi]` ancora o joelho exatamente quando não-vazio. **A Teoria está certa.** ### 2.2 Onde quebra Quando o intervalo é **vazio** (`λ_lo > λ_hi`, o caso de espectro liso), as duas implementações divergem: - **`.pyx:118-124`** — devolve `lambda_c = 0.05` incondicionalmente e `ancora=False`. - **`.py:915-930`** — faz busca entre os candidatos `{φ}` e devolve o melhor. **[PROVADO]** — 4 de 6 espectros de teste divergem: | espectro | `.pyx` (k, λ) | `.py` (k, λ) | |---|---|---| | `1/k^1.2`, d=32 | (2, **0.0500**) | (2, **0.4200**) | | `1+0.001k`, d=32 | (5, **0.0500**) | (5, **0.4979**) | | `k^-2`, d=32 | (2, 0.3704) | (2, 0.3704) ✓ | | `rank-1` | (4, 0.0500) | (4, 0.0500) ✓ | | `d=4` | (3, 0.3252) | (3, 0.3252) ✓ | | Dirichlet(64) | (12, **0.0500**) | (12, **0.5000**) | ### 2.3 Por que isso importa O `.pyx` é o caminho **rápido** (`criterios.pyx` é importado por `acelerado/__init__.py` com auto-build), logo é o que roda em produção. Ou seja: **no caso de espectro liso — que é o caso comum em buffers de features de alta dimensão — o sistema devolve λ_c = 0.05, um trilho, em vez da equação.** Isso não é um erro de arredondamento. É a equação declarada como "descoberta por análise matemática" caindo no *fallback* silenciosamente. E é o inverso do que o README reporta: `λ_c* = 0,566` do espectro real, com joelho `K̃=4`. **Correção:** `correcoes.py::lambda_c_unica` implementa a busca do `.py`. O `.pyx` deve casar. Teste de equivalência: comparar as duas em 200 espectros sintéticos (pow-law, exponencial, Dirichlet, ruído) e exigir igualdade exata. ### 2.4 Nota sobre a Teo 28.1-ii A família `J_λ(K) = ε²(K) + λ(b(K)−ε²(K))` com inclinações `s(K)=b(K)−ε²(K)` estritamente crescentes — verifiquei. O envelope inferior côncavo e `K*(λ)` não-crescente também verifiquei. **Isso está certo.** O problema não é a teoria; é que `b(K)` é o modelo errado (§3). --- ## 3. Defeito 2 — O trade-off K é dimensionalmente incoerente **[PROVADO]** ### 3.1 O modelo atual `gsq_rco.py:790-800`: ```python custo = (1.0 - lambda_comp) * eps2 + lambda_comp * bits # bits = log2(ks) / log2(max(d, 2)) ``` ### 3.2 O problema **O termo `b(K) = log₂K / log₂d` não tem unidade de custo.** Um índice de K átomos e um índice de d dimensões são *a mesma quantidade de informação*. Guardar o índice custa `log₂K` bits. Não existe denominador. O `/log₂d` normaliza para `[0,1]` e **destrói a aditividade** do custo. **[PROVADO]** — o mesmo K=4 tem custo de índice idêntico, mas o código reporta: | d | custo **real** | custo **do código** | erro | |---|---|---|---| | 8 | 2.000 bits | 0.667 | 3.0× | | 64 | 2.000 bits | 0.333 | 6.0× | | 512 | 2.000 bits | 0.222 | 9.0× | | 4096 | 2.000 bits | 0.167 | 12.0× | O tradeoff `J(K)` muda **só porque `d` mudou** — e `d` não é uma escolha de compressão, é a largura do modelo. O código penaliza o modelo por ser largo. ### 3.3 O problema mais grave: o custo real é `K·d` Armazenar o codebook custa **K·d parâmetros**. Para orçamento fixo `B`, os pares `(K, d)` com `K·d ≤ B` formam uma hipérbole. Sobre ela, `ε²(K)` depende **só** do espectro (rank intrinseco), não de `d`. **[PROVADO]** — para rank intrinseco fixo `r=2`, variando `d`: | d | K* | custo real | E(K*) | |---|---|---|---| | 64 | 2 | 0.02 Mbit | 1.000 | | 512 | 2 | 0.02 Mbit | 1.000 | | 4096 | 2 | 0.13 Mbit | 1.000 | O ganho de energia é **zero** entre d=64 e d=512, mas `J` é constante. O critério **não penaliza o custo que o requisito declara querer** ("menor consumo de RAM"). ### 3.4 Nota: `K > d` é Category error `gsq_rco.py:817` varre `K` de 1 a `d` e usa `ε²(K) = 1 − Σ_{j≤K}λ_j/Σλ_j`. Isso é correto **e** já restringe `K ≤ d` implicitamente. Mas a Teoria fala em "subespaço K-dimensional ortonormal em `R^d`" e "codebook Stiefel" como se `K` e `d` fossem livremente independentes. Não são: `K ≤ d` sempre, e o `λ_c` resultante é função de `d` **por esta razão estrutural**, não pela razão de custo que o docstring invoca. **Correção:** `correcoes.py::j_rate_distortion` — modelo de Rate–Distortion com `D(K,d) = bits_por_param · K · d / n` (custo por amostra, unidade comparável) e `R(K) = ε²(K)` (nats). Verificado: para `d=64/512/4096` o `K*` é **1** com `custo_ram_param=64` — o modelo agora *reage* a `d` na direção certa, porque o custo é explícito. --- ## 4. Defeito 3 — TE (Erro Topológico) não mede erro de representação ### 4.1 O que o código faz `criterios.pyx:200-215` e `SOMKohonen.te`: ``` te = fração com dist_posicional(BMU, 2º-BMU)² > 1.5 ``` ### 4.2 Por que está errado Isto mede **geometria da grade**, não erro de codificação. - Duas amostras **semanticamente idênticas** caindo em células vizinhas → `TE = 0` (falso negativo: a representação falhou e o TE não acusa). - Duas amostras **opostas** em células distantes → `TE = 1` (falso positivo: nada de errado na representação). O limiar `1.5` é uma **constante mágica de posições de grade**, que não tem relação com nenhuma unidade de erro. ### 4.3 O que o TE deveria ser - **QE** (Erro de Quantização) — já está correto no código: `min_j‖x−w_j‖²`. É a métrica padrão da literatura. - **TE no sentido Kohonen** — também `Σ‖x−w_c(x)‖²/N`. Idêntico ao QE aqui. - **TE topológico no tempo** (GSOM, Def. 3.4) — o que *de fato* é "erro topológico": ``` TE(t) = (1/N)·Σ_j o_j(t)·‖w_j(t) − w_j(t−1)‖² ``` com `o_j(t)` a ocupação. Mede se as células **ativas** estão convergindo. **Correção:** `correcoes.py::te_quantizacao` e `te_consistencia_temporal`. Verificado: o segundo dá 4.1e-4 para deriva de 0.01 nas células ocupadas e **distingue** casos que o TE posicional não distingue. **Impacto no README:** o critério `te` tem peso **0.10** em `criterios_ganho.py:44` e `te=0` é reportado como "δ_ort 1,5e-06, aprovado". Esse número **não mede o que a tabela diz que mede**. --- ## 5. Defeito 4 — Gate de modalidade é um parâmetro morto **[PROVADO]** `percepcao/fusao.py:57`: ```python gates[m] = float(g[i]) # <-- corta o grafo autograd ``` `logits_gate` é um `nn.ParameterDict` com `requires_grad=True`, entra num `softmax`, e o resultado é convertido para `float` Python. O tensor `g` só aparece em `gates`, que é devolvido mas **nunca participa do cálculo de `fus`**. **[PROVADO]** — `logits_gate['imagem'].grad is None` após `backward()`. O parâmetro **nunca** recebe gradiente. Não há learning rate que corrija isto. **Nota (importante sobre a correção):** a correção *óbvia* também falha. Se fizermos `fus = ancora + Σ_m g_m·CrossAttn(ancora,kv,kv)`, o contexto cross-attention é o **mesmo** para todas as modalidades, logo `Σ_m g_m·ctx = ctx·Σ_m g_m = ctx·1` — a saída é **invariante** ao gate, e o gradiente é **exatamente 0**. Verifiquei numericamente antes de descobrir isso. O gate precisa ponderar algo que **difere** por modalidade — as projeções `proj_m(emb_m)`. A correção final pondera as chaves/valores: ``` h_m = proj_m(emb_m) · g_m ; fus = ancora + CrossAttn(ancora, [h_m], [h_m]) ``` **[PROVADO]** — gradiente não-nulo em todos os 4 casos testados (1, 2, 3, 4 modalidades), zero parâmetros mortos, e o gate **de fato se move** no treino (|grad| ~ 1e-5, gates 0.25→0.253 após 200 passos). --- ## 6. Defeito 5 — A "cota" do viés do roteador S-SOM não é cota **[PROVADO]** `percepcao/roteador_ssom.py:147-152`: ```python bonus = lambda_rota * (log(conf) + log(n_tarefas)) bonus = bonus.clamp(min=0, max=lambda_rota * log(n_tarefas * 1e3)) ``` O clamp superior vale `0.35 · log(4000) = 2.90`. O docstring afirma *"nunca dominante, cota Teorema 18.2"*. **[PROVADO]** — com `conf=0.97` o viés real é **0.4745** (1.36× `λ_rota`); o teto teórico é 2.90. Escores de gate do MoE são `W_g·h + b` com `‖W_g‖ = O(1)` → escores `O(1)..O(5)`. Um viés **aditivo** de 2.90 domina o roteamento inteiro. **Lema.** *Se `s_e` são escores de gate e `b` é um viés aditivo não-acotado, existem entradas com `‖s‖₁ < 1` para as quais `argmax(s+b) ≠ argmax(s)`. Logo `b` só é "não dominante" se `|b| ≤ m/2` com `m = min_{e≠e*}(s_{e*}−s_e)` — o que exige conhecer `s`. Como `s` é desconhecido a priori, a única construção escala-invariante é multiplicativa.* **Correção:** `correcoes.py::vies_roteador_log` — `ν = ν_max·(log(C·conf)/log C)²`, `ν ≤ 0.5`, aplicado como `s·(1+ν)`. **[PROVADO]** — invariância de escala `argmax(as) = argmax(s)` para `a ∈ {0.1, 1, 10, 100}`; `ν=0` quando `conf=1/C` (nascimento neutro correto); `ν=0.478` quando `conf=0.97`. --- ## 7. Defeito 6 — A difusão não sonha (falta o sinal de erro) ### 7.1 Diagnóstico `geracao/difusao.py:349-365` (`compreensao_geracional`): ```python emb_out = modelo.enc_imagem(t) if orquestrador is not None: with torch.no_grad(): orquestrador.treinar_memoria(emb_out.detach().reshape(-1, modelo.d), epocas=1) ``` Três fatos: 1. `emb_out.detach()` + `no_grad` → **nenhum gradiente**. O encoder de imagem não é treinado pelo ciclo de difusão. 2. Só a grade SOM muda. O encoder fica intacto. 3. **Não existe sinal de erro.** O sistema não tem como saber se o sonho estava certo ou errado. O `vantagem_difusao` em `vit_lra.py:410` admite isso — mas é um critério de **mão** (`escassez and baixa_diversidade`), não uma perda. ### 7.2 Defeito adicional no RoteadorDifusao **[PROVADO]** `difusao.py:113-120`: o prior por intenção é calculado (`_PRIOR_INTENCAO`) e guardado em `escores`, mas **nunca participa de uma decisão** — não há `argmin`, `argmax` nem comparação. `decidir("ocr", False, False)` e `decidir("tts", False, False)` retornam **idêntico**. A Teo 25.8/25.9 é verdadeira mas **inócua**: a partição dura já determina tudo, e o prior é telemetria morta. ### 7.3 Defeito adicional: Teo 17.1 é código morto **[PROVADO]** `nucleo/modelo.py:835-841` computa `emb_in` mas **nunca computa `emb_plano`** (permanece `None`). Logo `forca_por_similaridade(None, None)` retorna o default **0.55** sempre. A "força semântica" —就是不metida no README — é constante. **Correções:** `jepa_mundo.py::MotorSonho` (sinal de erro + admissão por percentil) e a necessidade de computar `emb_plano` do estado oculto do plano textual, conforme o próprio docstring do Teo 17.1 já previa. --- ## 8. JEPA — a arquitetura que falta ### 8.1 Por que o projeto precisa (e a prova) **Observação:** `grep -rniE "jepa|target_encoder|ema_target|momentum_encoder|world_model|predictor_latent"` sobre `src/khtst/` retorna **zero**. Não há aprendizado de representação preditiva em lugar nenhum. **Teorema 5.1 (JEPA corta variância sem aumentar viés).** *Setup:* o KHTST minimiza `L_CE = E[−log p_θ(x|x_= τ_efetiva AND entropia_gate <= limite` usa um valor que nunca responde ao estado real. O `feedback` decide sempre com a mesma segunda condição. **Proposta (TE —闭合 loop):** ```python # 1. PERCEPÇÃO DO AMBIENTE: usar o que já existe # a entropia da sonda está disponível em criterios.pyx:esforco_entropia_lote H_norm, margem, p_max = esforco_entropia_lote(logits_sonda) # H_norm ∈ [0,1] entropia_gate = float(H_norm.mean()) # real, não 0.5 # 2. PERCEPÇÃO DO RESULTADO DA AÇÃO: o que o mundo devolveu # a ferramenta retorna string; medir se responde à pergunta r = self.tools.executar(nome, entrada) coerencia = self._coerencia_resposta(pergunta, r) # 0..1 # usar a MESMA métrica de coerência de criterios_ganho.py:51 (bigramas) # 3. AUTORRECOMPENSA com sinal, e não com streAk de perda # sinal = Δ(métrica do objetivo) atribuível à ação sinal = (p_cal - p_cal_anterior) * coerencia if sinal > 0: # PERCEPÇÃO POSITIVA → recompensa self.hub.atributo("ciclo/recompensa", +1) self.modelo.reforcar(acao, sinal) # ← congela/reforça o gradiente elif erro_ferrou: # PERCEPÇÃO NEGATIVA → punição self.hub.atributo("ciclo/punicao", +1) self.modelo.punir(acao, |sinal|) # ← gradiente negativo no caminho ``` **A conexão com o JEPA (que é a parte interessante):** `reforcar`/`punir` não precisam ser novos módulos. A autorecompensa pode ser **direcionada pelo gradiente do predictor JEPA**: quando uma ação produz um resultado que o predictor **não consegue prever** (alto `e_sonho`), isso é evidência de erro → punição. Quando o predictor acerta, o caminho da ação recebe reforço. Isso é `error-driven learning` (Schmidhuber) conectado a um objetivo de representação, e usa a infraestrutura de `MotorJepa` já proposta. --- ## 11. Tabela de correções | # | arquivo:linha | defeito | gravidade | correção | status v15.1 | |---|---|---|---|---|---| | 1 | `criterios.pyx` vs `gsq_rco.py` | equações divergem | **crítico** | `correcoes.py::lambda_c_unica` | ✅ `gsq_rco.py::lambda_c_autoajustavel` (equivalência 206/206) | | 2 | `gsq_rco.py:790` | custo de bits incoerente | **crítico** | `correcoes.py::j_rate_distortion` | ✅ `custo_bits_codigo` + `ajustar_k_tau_min(d_real=…)` | | 3 | `criterios.pyx:200`, `som_base.py` | TE mede geometria | **alto** | `correcoes.py::te_consistencia_temporal` | ✅ QE + TE temporal em `correcoes.py` (monotono na deriva) | | 4 | `fusao.py:57` | gate = parâmetro morto | **alto** | `correcoes.py::fusao_gated` | ✅ `fusao.py` com kv·g, g=2·sigmoid (nasce neutro, grad vivo) | | 5 | `roteador_ssom.py:150` | "cota" não é cota | **alto** | `correcoes.py::vies_roteador_log` | ✅ viés multiplicativo ν≤λ_rota, consumidores em `moe.py` adaptados | | 6 | `difusao.py:349` | sonho sem sinal de erro | **alto** | `jepa_mundo.py::MotorSonho` | ✅ hook `motor_sonho` em `compreensao_geracional` (admissão condiciona a memória) | | 7 | `difusao.py:113` | prior de intenção inócuo | médio | usar `escores` no `argmax` | ✅ telemetria viva (partição dura preservada — Teo 25.8 correta) | | 8 | `modelo.py:836` | `emb_plano` sempre `None` | médio | computar do plano textual | ✅ já aplicado na v12 (emb_plano REAL, Teo 17.1) | | 9 | `ciclo.py:145` | `entropia = 0.5` hardcoded | **alto** | usar `esforco_entropia_lote` | ✅ sonda real H/log V do modelo; falha ⟹ None explícito (nunca constante) | | 10 | `ciclo.py:150` | sem autorrecompensa | **alto** | §10 | ✅ sinal = Δp·coerência com traço + hub (recompensa/punição) | | 11 | todo o pacote | **sem JEPA** | **crítico** | `jepa.py::MotorJepa` | ✅ `src/khtst/treino/jepa.py` + wiring no `TreinadorExtensao` (λ_jepa>0) | --- ## 12. Ordem sugerida de implementação 1. **Unificar a equação de λ_c** (defeito 1) — é a novidade declarada e hoje não funciona no caminho de produção. Escrever teste de equivalência `.pyx` ≡ `.py`. 2. **Corrigir o modelo de custo** (defeito 2) — invalida o resultado do passo 1. 3. **JEPA** (`jepa.py`) — adiciona o que o projeto declara fazer e não faz. Começar com `lam_jepa` pequeno (0.1) e `d_latente` modesto (32), A/B contra a v15 atual pelo mesmo protocolo do README (mesmo corpus, mesmo número de updates efetivo). 4. **Gate de fusão** (defeito 4) — correção de 10 linhas,-zero risco, destrava 6 parâmetros (+0.03% de params) que hoje são inúteis. 5. **TE correto** (defeito 3) — antes de usar `te` como critério de ganho. 6. **Motor de sonho** (`jepa_mundo.py`) — depois de 3, porque depende do sinal. 7. **Autopercepção ativa** (§10) — `entropia_gate` real primeiro (mudança de uma linha), depois a autorrecompensa. **Métrica de sucesso proposta** (honesta, sem constante mágica): ``` Δppl por 1000 passos (a cada 1000 passos) ‖QᵀQ − I‖_F das matrizes Stiefel (deve permanecer ~ε) d Taxa de células SOM efetivamente usadas (subir = memória viva) perda JEPA (descer = representação aprendendo) e_sonho e sua taxa de admissão (estabilidade = sonho calibrado) ``` Todos já são computáveis com a infraestrutura existente mais `jepa.py`. --- ## 13. Nota final sobre o que **não** afirmo - Não rodei o treino. As conclusões sobre convergência são **conjecturais** e precisam do A/B de 9 h do protocolo do README. - As correções foram testadas como **funções isoladas**, não integradas ao `KHTSTModel` completo (que exige `torch` + datasets). - O `percepcao_conjunta` está `ativo: False` em `configs/base.json` e não foi exercitado. - A divergência λ_c (defeito 1) assume que o `.pyx` **é** o caminho de produção. Se o runtime cair para o `.py` por falha de build, a divergência é inócua — mas então o ganho de velocidade do Cython desaparece, e o README reporta o `.pyx` como o caminho rápido. - `[PROVADO]` = executado neste sandbox, output reproduzido em `verificacao/`. Ausência de marcador = leitura de código. --- ## 14. v15.1 — Auditoria de segunda ordem: corrigir as correções A camada de correções (patches) e a integração na produção foram elas mesmas auditadas — com o mesmo rigor da Seção 2–7. **Sete defeitos novos foram provados e corrigidos.** Moral do capítulo: correção sem verificação é só outro rascunho. ### 14.1 Os 7 defeitos de segunda ordem [TODOS PROVADOS e CORRIGIDOS] | # | onde | defeito | prova | correção | |---|---|---|---|---| | S1 | `jepa_mundo.py::passo_sonho` | **Admissão INVERTIDA no aquecimento**: `e >= limiar()=+inf` é FALSO ⟹ TODOS os sonhos eram ACEITOS antes de `min_amostras` — o oposto do Teorema 6.1 declarado (a própria Seção 9.1 reportava "86,7% de admissão", inconsistente com "nada é aceito") | execução: 60 sonhos no aquecimento ⟹ aceitos 100% | bloqueio EXPLÍCITO de aquecimento (`len(erros) < min_amostras ⟹ rejeita`); Teo 6.1 agora vale na forma exata | | S2 | `jepa_mundo.py::limiar` | O "quantil" era a **média dos maiores ⌈q·n⌉ erros** — situa-se acima do quantil q (taxa de admissão ≈86% com q=0.6) | `limiar(q=0.6)` ≠ `np.quantile(erros, 0.6)`; admissão 0.537 vs 0.86 antiga | quantil EXATO por interpolação linear; taxa estacionária ≈ q **[VERIFICADO: 0.537 ≈ 0.6]** | | S3 | `jepa_mundo.py::passo_sonho` | Sonho SEM contexto entrava com `e=0` (auto-comparação) e **peso 1.0 na memória** — poluição gratuita do SOM | caminho `emb_contexto=None` aceito com peso máximo | sem sinal de erro ⟹ medido, contabilizado, NÃO admitido (relatório §7.1-iii) | | S4 | `jepa.py::taxa_sucesso_media` | **Placeholder 0.5** — a tabela de μ (Teo 5.6) nunca se adaptava; `historico` sem teto (fuga de RAM em treino de 9 h) | leitura + execução: μ constante 0.9999 | deque com teto (`janela_telemetria`); taxa REAL alimenta `tabela_mu`; **[VERIFICADO: μ=0.9997 com taxa 0.023]** | | S5 | `jepa.py::mascara_contexto` + `EncoderAlvoEMA` | Parâmetros órfãos: `tau` recebido e ignorado (horizonte era ficção); `warmup` morto (rampa não existia) | leitura: `tau` não aparece no corpo | `eps ∈ {τ..τ+eps_max}` (horizonte ≥ τ, Teo 5.4-b); rampa μ_t = μ·t/warmup **[VERIFICADO: μ(1)=μ/warmup]** | | S6 | `jepa.py::FunilLatente` | **VOG com lote 1 ⟹ NaN**: `std(dim=0)` com ddof=1 divide por zero | `FunilLatente(16,8)(torch.randn(1,T,16))` ⟹ ‖∇‖=NaN (warning do PyTorch) | `correction=0` (desvio populacional) + piso 1e-4; **[VERIFICADO: ‖∇funil‖=7.1e-01]** | | S7 | `verificar_tudo.py` §5 (original) | Teste **insatisfazível**: exigia gradiente em modalidades AUSENTES (sem entrada não há caminho no grafo — impossível sem acoplar logits via softmax global, o que quebraria o nascimento neutro) | construção | check corrigido: zero parâmetros mortos ENTRE AS PRESENTES; ausentes com grad None é o CORRETO | ### 14.2 A equação de λ_c, agora ÚNICA (defeito 1 fechado) `patches/correcoes.py::lambda_c_unica` ≡ `src/khtst/quanta/gsq_rco.py::lambda_c_autoajustavel` — mesma busca de candidatos no intervalo vazio, mesmo custo rate–distortion. **Equivalência: 206/206 espectros idênticos** (6 nominais + 200 sintéticos: lei de potência, exponenciais, Dirichlet, ruído). Valores no espectro liso (onde o `.pyx` antigo devolvia a constante 0.05): | espectro | `.pyx` antigo | v15.1 (equação única) | |---|---|---| | `1/k^1.2`, d=32 | 0.0500 (trilho) | **0.4200** | | `1+0.001k`, d=32 | 0.0500 (trilho) | **0.4979** | | Dirichlet(64), d_real=192 | 0.0500 (trilho) | **0.5860** (ancorado, K̃=12) | Propriedades do Teorema verificadas sob o custo RAM: φ∈(0,1); K*(λ) não-crescente; K*(0⁺)=d e K*(1⁻)=1 **no limite** (com cauda quase-nula, K*=d vale só em λ→0 — a prova do endpoint é por limite, não por λ=0.02: J(K0`, μ=0.9999 seguindo a taxa real, telemetria `jepa/*` viva; com `λ_jepa=0` nenhum parâmetro novo (nascimento neutro). ### 14.7 JEPA em números (após todas as correções) encoder sintético (6,12,16), 500 passos AdamW(1e-3), seed 2026 (determinístico): | passo | perda | var. latente | taxa sucesso | μ | |---|---|---|---|---| | 0 | 4,525 | 0,97 | — | — | | 499 | **2,295 (−49,3%)** | 0,93 | 0,023 (REAL) | 0,9997 | Sem colapso (var O(1)); telemetria com teto (500 passos ⟹ janelas=100). Ciclo: sonda de entropia real H/log V = 0,996 sobre entrada real (nunca 0,5); autorrecompensa Δp·coerência registrada no traço e no hub. ### 14.8 Verificação final consolidada | camada | resultado | |---|---| | `patches/verificar_tudo.py` (9 seções) | **49 ✓ / 0 ✗** — 3 execuções determinísticas | | equivalência λ_c produção ≡ verificação | 206/206 espectros + hash SHA-256 igual | | suítes do repo (v1–v14) | **todas verdes**: 25, 36, 37 ✓ (v1–v4); 32 ✓ (v5); 48 ✓ (v6); 44 ✓ (v7); 21 ✓ (v9); OK (v10); ✓ (v11); 28 ✓ (v12); 27 ✓ (v13); 40/40 ✓ (v14, T27.6 atualizado ao custo corrigido) | | smoke de integração (`scripts/18`) | **13 ✓ / 0 ✗** (3 bugs de integração I1–I3 pegos aqui) | | teste com DADOS REAIS (`scripts/10`) | **APROVADO** — 32 registros reais de 5 famílias, 3 passos com perda estável, classificador de protótipos acc 1,00 (uniforme 0,083), DPO com 12 pares reais hh-rlhf (acc 0,75), estado 81,3 MB < 900 MB reload bit-exato | ### 14.9 O que NÃO afirmo nesta versão - A corrida longa de 9 h continua pendente — as projeções de ganho JEPA (Δppl/1000 passos) seguem conjecturais até o A/B. - `perda_sonho_treino` (L_sonho com gradiente) está implementada e verificada isoladamente; o gancho no laço de treino completo exige difusão real (diffusers) e fica para a corrida longa. - A autorrecompensa é TELEMETRIA DE SINAL (traço + hub) — a injeção de gradiente por reforço no caminho da ação (§10) permanece proposta. - O caminho Cython (`.pyx`) de `criterios` deve espelhar `lambda_c_unica` na próxima compilação — hoje a produção Python já usa a equação única, e o teste de equivalência (206 espectros + SHA-256) travará qualquer divergência futura. ## 15. v16 — KHMAMBAJEPA: torchao real · MC-JEPA Cython · autorregulação total · robô+matemática A v16 empilha a camada JEPA de larga cobertura sobre o v15.1, com o requisito "priorizar Cython", quantização torchao REAL com detecção automática CPU/GPU e a autorregulação de TODO parâmetro no treino E na inferência. Provas completas em `docs/matematica/28`; plano/memória em `PLANO_KHMAMBAJEPA.md`. ### 15.1 Descobertas e provas novas (doc 28) | # | achado | prova | verificação | |---|---|---|---| | T28.1 | cota do erro de quantização uniforme: RMS ≤ h/√12 (por canal, b bits) | momento central da uniforme no bin | medido 3.9e-3 ≤ teórico 3.9e-3 | | T28.2 | peso torchao é CONSTANTE (inferência-only) | subclass Int8Tensor sem gradiente | compressão 3.92× (78.8→10.1 MB de peso) | | T28.3 | exclusões obrigatórias: lm_head (sensibilidade exponencial da softmax), especialistas MoE (`torch.stack` não implementado no subclass — descoberto PELA suíte), camadas finas (erro relativo dominante) | Weyl multiplicativa + despacho ausente | forward pós-quant OK; quantizar MoE reproduzia a falha | | T28.4 | rollback atômico FP32 | cota superior (erro 0) | dim_minimo=99999 ⟹ FP32 intacto | | T28.9 | gradiente ANALÍTICO do VICReg (o rascunho calculava a perda SEM gradiente): variância com CANCELAMENTO EXATO do centro (Σ centrado = 0); covariância na forma fechada (X̃C)−C_bb·X̃ com projeção de centro NÃO cancelável | eqs. 28.12–28.14 | FD sem-kink 4.2e-11; ≡ autograd torch 9.6e-9; **o fator ½ que duas verificações inconsistentes mascararam foi EXPOSTO pelo FD e corrigido** | | T28.10 | guarda anti-colapso do passo Brain-JEPA (o rascunho treinava colapsado): φ = frac{σ_j < 0.1γ} > 0.5 ⟹ REJEITA | colapso total é ponto fixo ruim de L_inv | φ=1.0 rejeita; treino real: colapso 0.0 | | T28.5–28.7 | autorregulação Robbins–Monro MULTIPLICATIVA (log-escala): Σa=∞, Σa²<∞ ⟹ convergência q.c.; duas escalas (Borkar); sinais lr (progresso padronizado), λ (razão aux ≤ ½), MoE (entropia das frações) | RM/Ljapunov + Hedge | convergência 0.9978 no campo 1−x; treino real demo: λ_moe_lb 1.00→1.74, lr 1.00→1.04 | | T28.8 | temperatura de inferência por ENTROPIA-ALVO: H(T) monótona (dH/dT = Var_p(z)/T²), raiz única, bisseção contrátil (erro ≤ (T_max−T_min)/2^k) | doc 21 Teo 21.4 | H(T_cal)=5.0045 (alvo 5.0); integrada em `gerar(temperatura_auto=)` | | T28.8-b/c | matemática com resposta canônica = sinal de erro ZERO (verificável); instrução do LeRobot é REAL (meta/tasks.parquet — fetchman: 902 instruções) | igualdade canônica | 240 registros de matemática + 43 de robô coletados de verdade | ### 15.2 Tarefas canônicas 12 → 14 (Teo 22.1 preservada) `robo` (grupo visual — câmeras LeRobot) e `matematica` (grupo textual) entram pela FONTE ÚNICA; `n_intencoes = len(TAREFAS)+1 = 15` dinâmico; prefixos `[robo]`/`[math]` no BPE; mistura renormalizada. As suítes v11/v12 que hardcodavam "12" foram migradas para `len(TAREFAS)`. ### 15.3 Datasets v16 (coleta REAL, orçamento honesto) 283 registros novos (corpus merge 903): fetchman 40 · gsm8k 40 · MATH-500 40 · hendrycks álgebra 40 · hendrycks number_theory 40 · OpenR1 40 · IFM 40 · robô com frame 3. **Degradados documentados**: `heatherwhite/math-collection` (só metadata_sample.jsonl — dados reais fora do Hub) e `3DTopia/4DNeX-10M` (tar.gz ~680 MB, gzip não amostrável por HTTP Range). Frames de câmera: ≤4 mp4/fonte com HEAD prévio; meta documenta quando o frame não veio — NUNCA imagem inventada. Defeito de integração achado no smoke: `trust_remote_code` foi REMOVIDO do datasets 5.x (o caminho antigo falhava imediatamente) — dispatcher corrigido. ### 15.4 A/B pareado real (120 passos, corpus 903, lote 4) | variante | perda início → fim | melhoria | held-out | observações | |---|---|---|---|---| | baseline v15 | 9.769 → 5.395 | **1.811×** | 6.697 | v15.1 exato | | v16 JEPA+VICReg(0.3)+autorreg | 9.713 → 6.679 | 1.454× | — | razão aux 0.8 VIOLA Teo 28.7-ii | | v16 JEPA+VICReg(0.1)+autorreg | 9.724 → 7.501 | 1.296× | 7.420 | razão aux 0.27 ✓ cumpre a cota | **Leitura honesta:** o baseline converge mais rápido em CE; a própria teoria explica (PCGrad com termo auxiliar dominante) e prescreve o ajuste (λ≤0.1). O que a v16 compra: representação sem colapso (var_latente 0.70), **torchao com Δperda 0.000** (int8 REAL 3.92× sem perda medível), autorregulação viva nos dois regimes, kernel Cython verificado, 14 tarefas com sinal verificável. Comparação definitiva de CE: corrida de 9 h (protocolo do README). ### 15.5 Estados e higienização Estados de treino ANTERIORES: nenhum no Hub (209 arquivos, zero .safetensors/.pt/.ckpt) nem no ambiente (busca ampla) — auditoria re-executada nesta versão. Checkpoints intermediários da coleta v16 (`ckpt_v16_*.pt`) APAGADOS após uso. Token: exclusivamente variável de ambiente; grep do padrão `hf_[A-Za-z0-9]{30,}` no stage = 0 ocorrências. ## 16. v17 — Pacote de aprimoramento: auditoria dos 6 módulos, 14 defeitos provados (D1–D14) e autorregulação HÍBRIDA (RM+PI+bisseção) com tabela de 18 sinais ### 16.1 Escopo e método Rodada de auditoria de lógica, integração e matemática dos 6 módulos submetidos (`difusao_gradiente`, `metricas_qe_ct`, `lambda_c_unificado`, `tradeoff_k`, `jepa`, `config`). Método: auditoria de 1ª ordem (o que o código faz) + de 2ª ordem (o que o docstring PROMETE vs o que o código FAZ) + prova de correção de cada defeito + suíte executável (`tests/test_khtst_v17.py`, 56 verificações). Tudo em pacote NOVO `src/khtst/aprimoramento/` — nenhum módulo de produção foi tocado (zero regressões: v1–v16 todas verdes). ### 16.2 Defeitos catalogados e corrigidos (doc 29 §§1–6, Teos 29.1–29.13) | # | defeito | correção | prova | |---|---|---|---| | D1 | difusão: λ_diff sem grad + controlador nunca chamado + perda sem λ — "autoajuste" triplo código morto | hipergradiente EXATO (L afim em λ ⟹ ∂L/∂λ = L_diff, erro ZERO) + âncora ρ(λ−λ₀)² com ótimo interior λ*=λ₀−L_diff/2ρ | Teo 29.2 | | D2 | sem EMA de pesos (amostragem ruidosa) | EMA Polyak opt-in (Jensen: L(θ̄) ≤ média L(θ_t)) | Teo 29.3 | | D3 | CT somava ‖Δz‖² sobre (B·D) — incomparável entre configs | CT por COORDENADA (÷B·D); invariância por isometria provada | Teo 29.4 | | D4 | ganho por conjunção de limiares fixos — sem nível de teste | Student-t + Bonferroni (P(falso ganho) ≤ α; medido 0/60) | Teo 29.5 | | D5 | te_antigo O(N·G) | cKDTree O(N·log G), ≡ força bruta (100 grades) | Teo 29.6 | | D6 | média da janela COMPUTADA E JOGADA FORA (delta usava ε² instantâneo) | sinal suavizado vivo (Var ÷W, sem viés) + modo reversão | Teo 29.7-i | | D7 | passo η constante — convergência só a O(η) | agenda η_t=η₀/(1+t/τ) — Ση=∞, Ση²<∞ ⟹ q.c. | Teo 29.7-ii | | D8 | C=1 fixo no modelo de Zador | Ĉ por OLS log-log + teste do modelo (inclinação) + shrinkage | Teo 29.8 | | D9 | λ_c estático (não conversava com o controlador) | resolver_K aceita λ_c adaptativo | integração | | D10 | condicional com dois ramos idênticos | stop-gradient único explícito | inspeção | | D11 | variância POOLADA sobre (T,D) — colapso parcial invisível | hinge POR DIMENSÃO (Jensen + lei da variância total ⟹ per-dim ≥ poolado sempre) | Teo 29.10 | | D12 | truncamento de comprimento (descarta energia) | pooling adaptativo (contração ‖Pz‖ ≤ ‖z‖/√r) | Teo 29.11 | | D13 | λ_jepa do config nunca usado; 0.01 hard-coded | L = λ_jepa·MSE + peso_var·hinge — campos vivos | Teos 29.10/29.13 | | D14 | QECTConfig.normalizar e DifusaoConfig.eta_lambda mortos | wired (QE relativo; passo do EG) | Teo 29.4/29.2 | Honestidades de processo desta rodada: (a) a primeira versão da prova do Teo 29.5 usava o range OBSERVADO no Hoeffding — inválido (o raio subestimado quebra a cota); corrigida para Student-t (TCL) com Hoeffding opcional sob raio DECLARADO; (b) o Teo 29.13 foi refinado: no ponto EXATO de colapso há kink (o autograd pode dar 0) — a verdade é que o colapso é MÁXIMO do hinge (não mínimo local), e a produção empurra a direção explicitamente; (c) a PRIMEIRA implementação do ControladorHibrido fazia DUPLA integração do termo I — a suíte prendeu (setpoint não convergia) e a recursão foi corrigida para a forma do doc 29, com convergência EXATA medida (θ=0.6000, e∞=0.0000). ### 16.3 Autorregulação híbrida — a arquitetura (doc 29 §§7–9, Teos 29.14–29.16) Recursão única para todo parâmetro regulável: `u_{t+1} = Π[u_t + a_t·s_t + b·e_t + c·Δe_t]`, θ=θ₀·e^u, a_t=a₀/(1+t/τ). Provas: telescoping do D (Σc·Δe = c·(e_T−e₀) — limitada por 2c·sup|e| para TODO T); permanência no conjunto seguro por projeção (com clamp final — exp(log b) arredonda a b+ε); duas escalas de Borkar (PI rápido rastreia, RM lento converge); anti-windup direcional. τ_qk: banda [80,120] com semântica PÓS-CLIP (ℓ=min(ℓ_nat,τ)) — modo escala exata (Teo 24.7: linearidade do logit) e modo bisseção com erro ≤ (τmax−τmin)/2^k. Tabela de 18 parâmetros (AdamW β₁/β₂/ε/wd · Muon momentum/escala/τ_qk · PRS η_up/η_down/T_ciclo/decay_piso/percentil · PESO_MOE · PESO_SOM · ABMO · CIAR · crescimento ×2) com nascimento neutro (centros = constantes v16), sinais adimensionais ±1, limites seguros com permanência EXATA, TelemetryHub 100% (35 chaves) e adaptadores aplicados e verificados no MuonClipAdamW REAL e no PRS. ### 16.4 Verificação - Suíte v17: 56✓ (hipergradiente, λ* analítico≡numérico, EG converge, Polyak, invariâncias QE/CT, nível do teste 0/60, KDTree≡bruta 100/100, fast≡ref 10⁴, D6 regressão, Ση/Ση², Ĉ+p̂+shrinkage, unimodalidade 20k, K* fechado≡numérico ≤1%, elasticidade d/2, Jensen 1000 espectros, contração do pooling, EMA cosseno monótona, máximo do colapso, fuga ×30, telescoping exato, anti-windup 500 adversos, setpoint e∞=0, τ banda, 18 controladores neutros→limites exatos, β₁≤β₂ pelo adaptador, hub 35 chaves, passo do otimizador real bem definido, PRS 5 campos). - verificar_tudo: 49✓ · Regressão v1–v16: TODAS verdes (25/36/45/37/33/49/45/✓/22/49/68/29/28/40/—/53) · smoke18: 13✓. ## 17. v18 — Robustez (§1–3 do requisito), IPC Modelo→Modelo (Rust/Cython) e família JEPA + SonicMoE + ReplaySSM **Entrada**: requisito v18 — falhas remanescentes (1.1.1–1.1.5), aprimoramentos matemáticos (2.1–2.5), melhorias lógicas (3.1–3.4), módulo de comunicação Modelo→Modelo em Rust/Cython, família JEPA (10 variantes) + SonicMoE + ReplaySSM em hardware chinês/CPU, plano Markdown com provas e memória .md. **Robustez (doc 30 §§1–2, Teos 30.1–30.6):** - **30.1/3.1** — guarda de ordem EMA do JEPA: contador `_passos_sem_ema` (tolerância = lote efetivo) lança `RuntimeError` quando `passo_pos_backward()` não segue o `optimizer.step()`; implementado no `MotorJepa` (produção) e no `JEPA` v17 (forwards com gradiente apenas — avaliação sob `no_grad` não conta). Viés provado: O((1−m)·η·G) por passo. - **30.2/2.4/1.1.5** — kernel Mamba-3 com clamps δ∈[1e-6,1−1e-6], A≤−1e-6 (contração SEMPRE; identidade na região válida ⟹ gradiente autograd intacto) + `verificar_estabilidade` para telemetria de anomalias. - **30.3/2.3/1.1.4** — `NormalizadorPerdas` (EMA por chave, fator = clip(EMA_CE/EMA_aux, 0.1, 1.0), warmup 20, nascimento neutro) aplicado a TODAS as 8 auxiliares antes do PCGrad — cota de dominação ≤ 10× (prova com ‖h′‖ ≥ ‖h‖·sinθ). - **30.4/2.2** — Newton-Schulz com precisão adaptativa: fp32 quando ‖G‖_F < 1e-3 (erro angular cai ~3.3e4×), bf16 preservado caso geral. - **30.5/2.1/1.1.2** — `weight_decay_muon=1e-4` desacoplado (shrink multiplicativo comuta com a decomposição polar; controla ‖W‖_* sem lutar com a ortogonalização). - **30.6/2.5** — GSQ τ_min 0.25→0.5 (Jacobian ≤ 1/(4τ) ≤ 0.5 — 2^L menos amplificação em L camadas), t_alvo 600→400 (T_τ = 400/ln30 ≈ 117.6); fonte única de constantes (`TAU_MIN_PADRAO`/`T_ALVO_PADRAO`) propagada aos 3 pontos de chamada. **Lógica (doc 30 §§0/3, Teos 30.7–30.8, requisito §3.2–3.4):** - **30.7/3.3** — `nucleo/validacao.py`: `validar_config` + `exigir_config_valida` (pré-condições dos teoremas a montante; aborta ANTES do treino; chamada na 1ª linha do `TreinadorExtensao.__init__`). - **30.8/3.4** — `telemetria/log_estruturado.py`: níveis DEBUG/INFO/WARNING/ ERROR em JSONL, rotação por tamanho (5 MB × 3 backups, custo amortizado O(1)), eco de WARNING/ERROR no stderr; hub integrado (histórico `deque` limitado — vazamento de memória eliminado; NaN/Inf → `hub.alerta`; QK-clip e colapso latente viram WARNING). - **1.1.3/3.2** — treinador refatorado: 4 mixins (lr/perdas/estado/fases) com métodos movidos VERBATIM + facade `TreinadorExtensao` (API pública intacta; 92 KB → 66 KB + 4 módulos focais). Regressão v1–v17 TODA VERDE após o movimento (evidência de preservação comportamental). **IPC Modelo→Modelo (doc 30 §4, Teos 30.9–30.10, requisito):** - Crate Rust completo (`src/khtst/ipc/rust/`: memfd selável, RingBytes SPSC, io_uring, socket SCM_RIGHTS, framing, FFI cbindgen) — código do usuário preservado e organizado em crate. - Produção em Cython (`khtst_ipc.pyx`, compila SEM cargo): memfd + seals, ring SPSC com atomics C11/GCC (`__atomic_*`, acquire/release — mesmo contrato de memória do Rust), layout binário idêntico (header 64 B, magic 0x4B485453); fallback puro-Python honesto; framing Python (header 24 B " baseline (7.04e-4) — gradiente extra CHEGA ao encoder real. - Gráficos: `graficos/v19/v19_evidencias.png` (3 painéis). **Correção de processo**: `patches/jepa.py` estava DIVERGENTE da produção (a guarda Teo 30.1 da v18 não foi espelhada) — hash SHA-256 dessincronizado detectado pelo `verificar_tudo` (48✓/1✗); sincronizado ⟹ 49✓/0✗. **Verificação**: suíte v19 NOVA — **34/34 verdes** (doc 31 citado em cada verificação); verificar_tudo **49✓/0✗**; regressão v1–v18 TODA VERDE (25/36/✓/37/32/48/44/21/✓/✓/28/27/40/—/✓/56/46). **O que NÃO afirmamos** (doc 31 §10): benefício de wall-clock CPU do SonicMoE nesta escala; benefício de CE em 96 passos (o acoplamento custa ≤ +0.09 de CE — benefícios de representação esperados em corrida longa/ probes downstream); economia de linhas com o gate atual (fator_trabalho=1).