livro: capitulos 2 e 3 (PT) + catalogo de figuras TikZ + parecer red-team do painel

book/FIGURES.md

@@ -0,0 +1,217 @@
+# Especificação do Sistema de Design de Figuras — ZEPHIRUM
+
+**Maturidade:** ESPECIFICAÇÃO  
+**Projeto Editorial:** ZEPHIRUM — A Computação Antes da Execução  
+**Direção Arte e Diagramação:** TikZ Vetorial / LaTeX  
+
+---
+
+## 1. Diretrizes do Sistema de Design
+
+### 1.1 Paleta de Cores Oficial
+
+O sistema visual de figuras do livro utiliza duas variantes cromáticas estritas: a **Versão Digital (Fundo Escuro)** para visualização em telas e PDF interativo, e a **Versão Impressão (Fundo Claro)** otimizada para impressão física em offset ou digital CMYK.
+
+#### Versão Digital (Dark Mode)
+* **Fundo Obsidiana (`bg_obsidian`):** `#05080b` (RGB: 5, 8, 11) — base profunda e neutra.
+* **Ciano Elétrico (`cyan_electric`):** `#70e5ff` (RGB: 112, 229, 255) — linhas primárias de fluxo, vereditos positivos (`1`, `DECIDED_WITHOUT_EXECUTION`) e destaque técnico.
+* **Dourado Nobre (`gold_noble`):** `#c5a065` (RGB: 197, 160, 101) / `#d4b584` (RGB: 212, 181, 132) — nós de decisão, certificados, estado `Z` (zephirum) e numerais.
+* **Cinza Metálico (`slate_gray`):** `#1e2530` (RGB: 30, 37, 48) — contêineres, fundos de caixas e bordas secundárias.
+* **Texto Primário (`text_light`):** `#e6ecf2` (RGB: 230, 236, 242) — rótulos e equações.
+* **Vermelho de Alerta (`alert_red`):** `#ff5555` (RGB: 255, 85, 85) — representação de vereditos `ERROR`, falhas ou resíduos custos.
+
+#### Versão Impressão (Light Mode)
+* **Fundo Claro (`bg_print`):** `#ffffff` ou creme editorial `#fbf9f5` — papel de alta gramatura.
+* **Ciano Profundo (`cyan_deep`):** `#005577` (RGB: 0, 85, 119) — fluxo e destaques principais sem perda de contraste em papel.
+* **Dourado Escuro (`gold_dark`):** `#9e7a3b` (RGB: 158, 122, 59) — nós formais e estado `Z`.
+* **Cinza de Estrutura (`slate_print`):** `#e2e8f0` (RGB: 226, 232, 240) — preenchimento de caixas.
+* **Texto Primário (`text_dark`):** `#05080b` (RGB: 5, 8, 11) — tipografia de alto contraste.
+
+---
+
+### 1.2 Template TikZ Padronizado
+
+Todas as figuras são produzidas em TikZ vetorial standalone. O preâmbulo padrão a ser adotado na compilação do livro é o seguinte:
+
+```latex
+\documentclass[tikz,border=10pt]{standalone}
+\usepackage{tikz}
+\usepackage{xcolor}
+\usepackage{fontspec}
+\setmainfont{Latin Modern Roman}
+\setsansfont{Latin Modern Sans}
+\setmonofont{Latin Modern Mono}
+
+\usetikzlibrary{shapes.geometric, arrows.meta, positioning, calc, backgroundes, chains, shadows}
+
+% Definição da Paleta Digital (Dark Mode)
+\definecolor{bgobsidian}{HTML}{05080B}
+\definecolor{cyanelectric}{HTML}{70E5FF}
+\definecolor{goldnoble}{HTML}{C5A065}
+\definecolor{goldlight}{HTML}{D4B584}
+\definecolor{slategray}{HTML}{1E2530}
+\definecolor{textlight}{HTML}{E6ECF2}
+\definecolor{alertred}{HTML}{FF5555}
+
+% Estilos TikZ Padrão
+\tikzset{
+  darkbg/.style={fill=bgobsidian, text=textlight},
+  nodebox/.style={rectangle, rounded corners=3pt, draw=cyanelectric, fill=slategray, thick, inner sep=8pt, text=textlight, align=center},
+  goldbox/.style={rectangle, rounded corners=3pt, draw=goldnoble, fill=slategray, thick, inner sep=8pt, text=textlight, align=center},
+  arrowflow/.style={-Stealth, thick, draw=cyanelectric},
+  goldarrow/.style={-Stealth, thick, draw=goldnoble},
+  alertbox/.style={rectangle, rounded corners=3pt, draw=alertred, fill=slategray, thick, inner sep=8pt, text=textlight, align=center}
+}
+```
+
+---
+
+## 2. Catálogo de Figuras Planejadas (16 Figuras)
+
+### Figura 01 (`fig01_jornada_numeral`)
+* **Capítulo:** Capítulo 4 — A jornada do zero
+* **Título:** A Genealogia Epistemológica do Numeral śūnya ao ZEPHIRUM
+* **Descrição Técnica:** Diagrama de fluxo histórico-etimológico e conceitual em linha temporal ramificada. Demonstra a evolução do numeral do nada até a trivalência. Exibe a transição śūnya (628 d.C., Brahmagupta) → ṣifr (Bagdá) → ṣiprā (siríaco) → zephirum (Fibonacci, 1202) → zero → ZEPHIRUM ($Z \equiv (|0\rangle + |1\rangle)/\sqrt{2}$). Na parte inferior, mostra a bifurcação entre a leitura lógica (estado $Z = \text{UNKNOWN}$), a leitura quântica (superposição $|+\rangle$) e a gramática do dual árabe (*ṣifrayn*).
+* **Fonte dos Dados no Repo:** `docs/CHARTER.md` (§4), `book/capitulos/cap04_pt.md`.
+* **Especificação de Estilo:** Nós retangulares horizontais interligados por vetores ciano (`#70e5ff`). O nó final $Z$ é destacado em caixa dourada (`#c5a065`) com brilho em degradê. A versão para impressão converte os vetores para ciano profundo (`#005577`) sobre fundo claro (`#fbf9f5`).
+
+---
+
+### Figura 02 (`fig02_custo_execucao_cega`)
+* **Capítulo:** Capítulo 2 — OBSERVAÇÃO: Computações que ninguém precisava fazer
+* **Título:** O Desperdício Computacional da Execução Cega vs. Análise ZCA
+* **Descrição Técnica:** Gráfico de barras comparativo de unidades de computação demandadas versus unidades efetivamente executadas sob o protocolo ZCA. Mostra a disparidade entre a abordagem tradicional (execução cega de 100% dos termos) e a abordagem ZCA, onde apenas o resíduo necessário é computado. Apresenta o detalhamento empírico de 3.784 unidades demandadas contra 789 executadas (eliminação de 79,15%).
+* **Fonte dos Dados no Repo:** `results/stress_results_500.json` (3.784 unidades originais, 789 executadas, 2.995 eliminadas).
+* **Especificação de Estilo:** Barra total de fundo cinza metálico (`#1e2530`) demarcando 3.784 unidades. Barra interna preenchida em ciano elétrico (`#70e5ff`) indicando 789 unidades executadas (20,85%) e seção hachurada em dourado (`#c5a065`) indicando 2.995 unidades eliminadas com certificado (79,15%).
+
+---
+
+### Figura 03 (`fig03_escada_zca`)
+* **Capítulo:** Capítulo 3 — HIPÓTESE: "Precisamos computar isto?" (e Capítulo 11)
+* **Título:** A Escada de Decisão ZCA (11 Degraus de Avaliação de Necessidade)
+* **Descrição Técnica:** Diagrama em cascata vertical descendente representando os 11 rungs do algoritmo ZCA (Necessity Compilation Algorithm). Mostra a travessia ordenada: 1. Identidade → 2. Invariante → 3. Simplificação → 4. Redução → 5. Limite → 6. Solução Analítica → 7. Aproximação Certificada → 8. Algoritmo Clássico → 9. Paralelização → 10. Simulação → 11. Computação Quântica. Em cada degrau, uma ramificação lateral indica o ponto de saída antecipada (`DECIDED_WITHOUT_EXECUTION` ou `DECIDED_BY_REDUCTION`) acompanhado da emissão do Decision Kernel.
+* **Fonte dos Dados no Repo:** `docs/CHARTER.md` (§9), `results/stress_results_500.json`.
+* **Especificação de Estilo:** Escada estilizada com degraus em cinza metálico (`#1e2530`), bordas em ciano (`#70e5ff`). Setas de saída antecipada em dourado nobre (`#c5a065`). Nós de parada final em vermelho suave para resíduo não eliminável.
+
+---
+
+### Figura 04 (`fig04_portao_trivalente`)
+* **Capítulo:** Capítulo 3 — HIPÓTESE: "Precisamos computar isto?" (e Capítulo 10)
+* **Título:** Diagrama de Estados e Portão de Decisão Trivalente ZEPHIRUM
+* **Descrição Técnica:** Máquina de estados finitos que rege o Decision Kernel. O estado inicial do problema é $Z$ ($\text{UNKNOWN}$). A avaliação do contrato $C$ sob tolerância $\varepsilon$ e orçamento $B$ força a transição determinística para um de cinco vereditos formais: $1$ ($\text{FULL\_EXECUTION\_REQUIRED}$), $0$ ($\text{DECIDED\_WITHOUT\_EXECUTION}$), $\text{REFUSED}$ ($\text{orçamento excedido/contrato violado}$), $\text{INCONCLUSIVE}$ (mantém $Z$) e $\text{ERROR}$ (inconsistência de premissa).
+* **Fonte dos Dados no Repo:** `PROTOCOLO_EXECUTIVO.md` (Vereditos da Linguagem), `book/capitulos/cap01_pt.md`.
+* **Especificação de Estilo:** Círculo central proeminente em dourado (`#c5a065`) para o estado $Z$. Transições de estado desenhadas como curvas direcionadas em ciano elétrico (`#70e5ff`). Estados finais representados por retângulos arredondados com código de cores: 0 e DECIDED em ciano, 1 em cinza, REFUSED/ERROR em vermelho alerta (`#ff5555`).
+
+---
+
+### Figura 05 (`fig05_pipeline_certificacao`)
+* **Capítulo:** Capítulo 12 — CERTIFICADOS E LEDGER
+* **Título:** Pipeline de Compilação, Emissão e Verificação Pós-Quântica ML-DSA-44
+* **Descrição Técnica:** Diagrama de arquitetura mostrando a separação estrita entre o Motor Gerador (ZCA Compiler Engine) e o Verificador Independente (Checker). O motor recebe o programa `.zeph`, executa a redução algébrica e emite o recibo estrito. O recibo é assinado via algoritmo pós-quântico ML-DSA-44 (FIPS 204). O Verificador Independente re-deriva os cálculos a partir das testemunhas brutas e valida a assinatura sem consultar o compilador.
+* **Fonte dos Dados no Repo:** `results/chsh_qkd_kingston.json`, `results/ghz20_sparse_ibm_fez.signed.json`, `results/hybrid_boundary_receipt.signed.json`.
+* **Especificação de Estilo:** Dois blocos de contaste isolados (Gerador à esquerda em ciano, Verificador à direita em dourado). No centro, o recibo assinado é representado como um documento estilizado contendo a chave pública FIPS 204 e o hash SHA-256 da prova.
+
+---
+
+### Figura 06 (`fig06_timeline_experimentos`)
+* **Capítulo:** Capítulo 14 — EXPERIMENTOS
+* **Título:** Linha do Tempo Experimental e Baterias de Falsificação (Outubro de 2026)
+* **Descrição Técnica:** Linha do tempo cronológica detalhando os marcos de validação experimental do repositório entre 06/10/2026 e 15/10/2026. Destaca a sequência: aprovação do Charter (06/10) → Teste de estresse N=500 e ataque de soundness (09/10) → Execuções de validação em hardware quântico (09/10 - 10/10, rungs GHZ 2 a 20 e H2) → Treinamento da Camada de IA Naive Bayes (14/10) → Replicação em escala N=500.000 (15/10).
+* **Fonte dos Dados no Repo:** `science_log/2026-10-14.jsonl`, `science_log/2026-10-15.jsonl`, `results/qpu_ledger.md`.
+* **Especificação de Estilo:** Eixo horizontal em dourado nobre (`#c5a065`) com marcadores circulares em ciano (`#70e5ff`). Cada marco exibe caixa com data, N de amostragem e taxa de eliminação verificada.
+
+---
+
+### Figura 07 (`fig07_correlacoes_bell`)
+* **Capítulo:** Capítulo 14 — EXPERIMENTOS
+* **Título:** Correlações de Bell em Hardware Quântico: Controle Positivo vs. Controle Separável
+* **Descrição Técnica:** Gráfico de dispersão com barras de erro bootstrap (IC 95%) comparando os correladores $\langle ZZ \rangle$ e $\langle XX \rangle$ para o par emaranhado Bell $|\Phi^+\rangle$ (veredicto exato 1) e o estado separável $|+0\rangle$ (veredicto exato 0). Apresenta a coerência observada no hardware real ($\langle ZZ \rangle = 0,8857$, $\langle XX \rangle = 0,9092$) contra o controle separável ($\langle ZZ \rangle = 0,0508$, $\langle XX \rangle = -0,0742$).
+* **Fonte dos Dados no Repo:** `results/bell_phi_plus_ibm_fez.json`, `results/separable_control_ibm_fez.json`, `results/language_cross_hardware_bootstrap.json`.
+* **Especificação de Estilo:** Eixos cartesianos $[-1, 1] \times [-1, 1]$. Pontos do Bell em ciano elétrico (`#70e5ff`) com elipse de confiança em dourado. Pontos do controle separável concentrados na origem $(0,0)$ em cinza metálico.
+
+---
+
+### Figura 08 (`fig08_falsificacao_soundness`)
+* **Capítulo:** Capítulo 6 — FALSIFICAÇÃO
+* **Título:** Resultados do Teste de Falsificação e Rejeição de Certificados Forjados (N=500)
+* **Descrição Técnica:** Diagrama de fluxo de auditoria mostrando o destino dos 500 problemas do teste de estresse e dos 20 ataques de integridade. Ilustra a distribuição: 292 decididos sem execução, 169 por redução, 3 com resíduo, 7 com execução completa e 29 mantidos em Z. Mostra a convergência de 100% na rejeição das 20 tentativas de forjar certificados de desnecessidade.
+* **Fonte dos Dados no Repo:** `results/stress_results_500.json`, `book/capitulos/cap06_pt.md`.
+* **Especificação de Estilo:** Fluxograma com divisões percentuais. Linha de ataque de forjamento em vermelho alerta (`#ff5555`) sendo bloqueada por um escudo estilizado do Verificador em dourado nobre (`#c5a065`).
+
+---
+
+### Figura 09 (`fig09_netbenefit_tradeoff`)
+* **Capítulo:** Capítulo 16 — RESULTADOS (e Capítulo 2)
+* **Título:** O Trade-off do NetBenefit Computacional: Custo da Análise vs. Economia Residual
+* **Descrição Técnica:** Gráfico de curva de benefício líquido ($NetBenefit = \text{Custo}_{\text{baseline}} - (\text{Custo}_{\text{análise}} + \text{Custo}_{\text{resíduo}} + \text{Custo}_{\text{verificação}})$). Demonstra a zona de benefício positivo quando as regras de redução eliminam repetições caras, e a zona de benefício negativo onde o custo de derivar a prova supera o custo da execução direta (casos de execução completa e `UNKNOWN`).
+* **Fonte dos Dados no Repo:** `results/stress_results_500.json` (NetBenefit de +2.946,23), `results/stress_results_500000.json` (+2.794.817,81 unidades).
+* **Especificação de Estilo:** Curva contínua em ciano elétrico (`#70e5ff`) sobre o eixo zero em cinza. Região acima de zero preenchida com transparência dourada (`#c5a065`, alpha=0.2); região abaixo de zero (custo líquido) destacada em vermelho suave.
+
+---
+
+### Figura 10 (`fig10_escala_ghz_ladder`)
+* **Capítulo:** Capítulo 14 — EXPERIMENTOS
+* **Título:** Decaimento de Coerência e População dos Polos no Ladder GHZ (N=2 a 20 Qubits)
+* **Descrição Técnica:** Gráfico de linhas comparando a população ideal dos polos $|0^N\rangle + |1^N\rangle$ medidos em hardware quântico real ao longo dos rungs $N \in \{2, 3, 4, 6, 8, 12, 20\}$. Mostra a atenuante física da decorrelação (97,9% em N=3; 95,1% em N=4; 91,8% em N=6; 72,5% em N=8; 53,5% em N=12; 39,7% em N=20 com suporte *sparse*).
+* **Fonte dos Dados no Repo:** `results/ghz3_fusion_ibm_fez.json`, `results/ghz_n_ladder_ibm_fez.json`, `results/ghz8_12_ladder_receipt.json`, `results/ghz20_sparse_ibm_fez.json`.
+* **Especificação de Estilo:** Curva exponencial decrescente em dourado nobre (`#c5a065`) com nós de dados marcados em ciano elétrico (`#70e5ff`). Barra vertical tracejada indicando o limite *sparse* em N=20.
+
+---
+
+### Figura 11 (`fig11_camada_ia_naive_bayes`)
+* **Capítulo:** Capítulo 14 — EXPERIMENTOS
+* **Título:** Desempenho da Camada Heurística de IA no Pré-Orçamento de Análise
+* **Descrição Técnica:** Matriz de confusão e gráfico de revocação (recall) por classe do modelo Naive Bayes treinado sobre 40.000 compilações prévias. Demonstra a acurácia global de 95,67% contra o baseline de 53,05%, com 100% de recall para `FULL_EXECUTION_REQUIRED`, 100% para `DECIDED_BY_REDUCTION` e 90% para `UNKNOWN`. Destaca a limitação honesta de 0% de recall para a classe rara `RESIDUAL_COMPUTATION_REQUIRED`.
+* **Fonte dos Dados no Repo:** `results/ai_layer_results.json`.
+* **Especificação de Estilo:** Matriz de calor $5 \times 5$ com tons de ciano elétrico (`#70e5ff`) para acertos elevados e cinza escuro para células nulas. A linha de resíduo é circundada por borda dourada com nota explicativa de limitação.
+
+---
+
+### Figura 12 (`fig12_h2_estudo_qpu`)
+* **Capítulo:** Capítulo 14 — EXPERIMENTOS
+* **Título:** Espectro de Energia do Estado Fundamental da Molécula H₂: Núcleo Exato vs. QPU
+* **Descrição Técnica:** Comparação entre o valor certified exato do estado fundamental da molécula de $H_2$ em geometria STO-3G ($d=0,75\,\text{Å}$, $E_{\text{exato}} = -1,145599\,\text{Ha}$) e a estimativa experimental obtida via circuito variacional em hardware quântico real ($E_{\text{QPU}} = -1,004784\,\text{Ha}$). Mostra o desvio de $+0,140815\,\text{Ha}$ dentro da banda de ruído NISQ sem mitigação.
+* **Fonte dos Dados no Repo:** `results/h2_energy_qpu_study.json`.
+* **Especificação de Estilo:** Duas linhas horizontais paralela de energia. Linha inferior sólida em dourado nobre (`#c5a065`) para o valor exato certified (-1,1456 Ha). Linha superior tracejada em ciano (`#70e5ff`) com barra de erro representando a medição em hardware (-1,0048 Ha).
+
+---
+
+### Figura 13 (`fig13_arquitetura_quatro_pilares`)
+* **Capítulo:** Capítulo 13 — OS QUATRO PILARES
+* **Título:** Visão Geral da Arquitetura ZEPHIRUM: Os Quatro Pilares e o NEXA-IR Transversal
+* **Descrição Técnica:** Diagrama em bloco de quatro colunas verticais representando os pilares funcionais da plataforma: 1. Language (especificação declarativa de contratos) → 2. Compiler (motor ZCA de simplificação e certificados) → 3. Simulator (validação de resíduos e falsificação) → 4. Runtime (orquestrador de backends CPU/GPU/HPC/QPU). O barramento horizontal inferior representa a representação intermediária NEXA-IR interligando todos os pilares.
+* **Fonte dos Dados no Repo:** `docs/CHARTER.md` (§11).
+* **Especificação de Estilo:** Quatro caixas verticais estruturadas em cinza metálico (`#1e2530`) com cantos arredondados, encimadas por ícones em ciano (`#70e5ff`). O barramento NEXA-IR atravessa a base em faixa dourada (`#c5a065`).
+
+---
+
+### Figura 14 (`fig14_qcnn_cluster_state`)
+* **Capítulo:** Capítulo 14 — EXPERIMENTOS
+* **Título:** Verificação do Estado de Cluster 1D para QCNN em Hardware Quântico
+* **Descrição Técnica:** Diagrama de circuito quântico e barras de estabilizadores para a célula de estado de cluster 1D $CZ|++\rangle$ (modelo Cong-Choi-Lukin 2019). Mostra a decisão exata $1$ ($\det = -0,5$) tomada offline e a validação experimental dos estabilizadores $\langle XZ \rangle = 0,918$, $\langle ZX \rangle = 0,844$ e $\langle ZZ \rangle = 0,012$ em QPU física.
+* **Fonte dos Dados no Repo:** `results/qcnn_cluster_ibm_fez.json`, `results/family_batch_hardware.json`.
+* **Especificação de Estilo:** Representação esquemática do circuito com portas em ciano elétrico (`#70e5ff`) e gráfico de barras lateral indicando as expectativas dos estabilizadores medidas no experimento.
+
+---
+
+### Figura 15 (`fig15_stress_scaling_500k`)
+* **Capítulo:** Capítulo 6 — FALSIFICAÇÃO (e Capítulo 14)
+* **Título:** Escalabilidade e Invariância de Soundness (N=500 vs. N=5.000 vs. N=500.000)
+* **Descrição Técnica:** Gráfico logarítmico demonstrando a estabilidade das métricas ZCA através de quatro ordens de grandeza de problemas (N=500, N=5.000 e N=500.000). Confirma que a taxa de eliminação permanece constante ($79,15\% \to 75,67\% \to 76,51\%$) e a taxa de eliminação falsa (false elimination rate) permanece exatamente em $0,0\%$ em todos os regimes.
+* **Fonte dos Dados no Repo:** `results/stress_results_500.json`, `results/stress_results_5000.json`, `results/stress_results_500000.json`.
+* **Especificação de Estilo:** Eixo X logarítmico (500 a 500.000). Duas linhas paralelas: linha superior de eliminação em ciano elétrico (`#70e5ff`) sustentada na faixa de ~76-79%, e linha inferior de erros em vermelho/dourado colada no eixo $0,0\%$.
+
+---
+
+### Figura 16 (`fig16_matriz_fronteira_hibrida`)
+* **Capítulo:** Capítulo 17 — FUTURO
+* **Título:** Matriz de Decisão da Fronteira Híbrida de Execução Clássico-Quântica
+* **Descrição Técnica:** Diagrama bidimensional de decisão onde o eixo X representa a complexidade algébrica da redução ZCA e o eixo Y representa a exigência de amostragem do contrato. Mapeia a alocação de recursos em quatro quadrantes: 1. Resolução Pura sem Execução ($0$); 2. Redução Clássica Determinística; 3. Simulação Numérica Aproximada; 4. Despacho para Backend Quântico.
+* **Fonte dos Dados no Repo:** `results/hybrid_boundary_receipt.json`, `results/hybrid_witness_marrakesh.json`.
+* **Especificação de Estilo:** Matriz $2 \times 2$ em cinza metálico (`#1e2530`). Quadrante superior direito (Quântico) demarcado por textura sutil em ciano (`#70e5ff`); quadrante inferior esquerdo (Não-execução) preenchido em dourado nobre (`#c5a065`).
+
+---
+
+## 3. Resumo de Cobertura e Conexão Editorial
+
+As 16 figuras acima cobrem a totalidade dos conceitos teóricos, históricos, arquiteturais e experimentais do livro *ZEPHIRUM: A Computação Antes da Execução*. Todas as especificação são diretamente ancoradas em arquivos de dados auditáveis do repositório, garantindo que nenhum elemento gráfico apresente dados fictícios ou incoerentes com os registros experimentais.

book/capitulos/cap02_pt.md

@@ -0,0 +1,120 @@
+# Capítulo 2: Computações que ninguém precisava fazer
+*ZEPHIRUM: A Computação Antes da Execução | Parte I: A Pergunta*
+
+## Nível 1: Para qualquer leitor
+
+Imagine uma grande biblioteca pública de alcance metropolitano onde cada visitante busca responder a uma dúvida simples: determinado livro sobre astronomia antiga está disponível para consulta nas estantes hoje? A abordagem convencional da computação moderna equivale a enviar uma equipe inteira de funcionários para percorrer todos os corredores, ler linha por linha cada obra existente no acervo, catalogar milhão por milhão os parágrafos, compilar um relatório enciclopédico de quinhentas páginas sobre a história da biblioteca e, ao final de semanas de trabalho exaustivo, entregar o documento ao visitante com a seguinte resposta na última linha: "sim, o livro está disponível na terceira prateleira do corredor B".
+
+Nenhum administrador de biblioteca sanidade preservada autorizaria um procedimento tão irracional e dispendioso. No entanto, é exatamente essa a arquitetura operacional implícita dos sistemas digitais contemporâneos. Todos os dias, processadores centralizados e clusters distribuídos realizam bilhões de operações aritméticas, resolvem sistemas complexos de equações e executam simulações numéricas massivas para responder a perguntas cujas respostas já estavam contidas, de forma implícita ou imediata, nos primeiros dados de entrada ou na própria estrutura conceitual da consulta.
+
+Considere um exemplo aritmético direto e cotidiano. Suponha que um sistema financeiro precise determinar se a soma de uma lista de oito transações em uma conta excede o limite de crédito de 100 unidades monetárias. As transações conhecidas na lista contêm os seguintes valores positivos: 60, 30, 20, 5, 4, 3, 2 e 1. A abordagem de execução cega, padrão nas linguagens imperativas tradicionais, executa a adição sequencial completa de todos os oito termos: calcula 60 + 30 = 90, depois 90 + 20 = 110, em seguida 110 + 5 = 115, continuando até somar o último termo para obter o total de 125, comparando só então esse resultado final com o limite de 100 para concluir que o valor excede o teto.
+
+Agora observe o que acontece quando a pergunta precede a execução. A pergunta central do contrato não é "qual é o valor numérico exato da soma de todas as transações?", mas tão somente "a soma total excede o limite de 100?". Avaliando apenas os três primeiros termos da lista, a soma parcial atinge 60 + 30 + 20 = 110. Como todas as transações restantes são comprovadamente não negativas, o fato de a soma parcial de 110 já ter ultrapassado o limiar de 100 é prova matematicamente suficiente para responder de forma definitiva à pergunta formulada. Os cinco cálculos adicionais (adicionar 5, 4, 3, 2 e 1) são absolutamente desnecessários para a tomada de decisão. Executá-los não adiciona um único bit de informação útil à resposta requerida.
+
+[FIGURA fig02_custo_execucao_cega]
+
+Um segundo cenário ilustra a mesma cegueira em domínios científicos. Imagine uma simulação meteorológica avançada acionada para responder se haverá precipitação pluviométrica superior a 50 milímetros em uma determinada praça pública amanhã ao meio-dia. O procedimento tradicional submete todo o modelo atmosférico global, dividindo o planeta em milhões de células tridimensionais, calculando dinâmica de fluidos, radiação solar e transferência de calor por horas a fio. Contudo, se a pressão atmosférica regional e os índices de umidade na camada limítrofe local já violam os pré-requisitos físicos mínimos para a formação de nuvens convectivas naquela janela temporal, a pergunta poderia ser respondida negativamente nos primeiros milissegundos por análise de invariantes, sem jamais disparar o integrador numérico de alto custo.
+
+A este fenômeno damos o nome de **cegueira de execução**: a incapacidade estrutural dos paradigmas de programação tradicionais de avaliar a necessidade de uma instrução antes de sua execução física. A cegueira de execução não é uma falha pontual de um programador descuidado; é uma propriedade intrínseca de sistemas projetados sob a premissa de que toda instrução escrita em um código deve ser levada até o hardware, independentemente de sua relevância para a pergunta do usuário. Essa cegueira dissipa gigawatts de energia elétrica em datacenters pelo mundo, satura barramentos de memória, inflaciona custos operacionais em nuvem e retarda decisões cruciais em sistemas de tempo real.
+
+## Nível 2: Para o cientista e o engenheiro
+
+Sob a ótica da engenharia de software e da arquitetura de sistemas, a eliminação de computações desnecessárias exige uma transição de métricas. Historicamente, a engenharia de desempenho concentrou esforços em acelerar a execução das instruções: introdução de instruções SIMD, paralelismo no nível de instrução (ILP), preditores de desvio hiper-especializados, memórias cache de múltiplos níveis, aceleração por hardware gráfico e pipelines de compilação JIT. Todas essas inovações tornaram os processadores extraordinariamente eficientes em executar instruções. Porém, executar uma instrução desnecessária dez vezes mais rápido ainda representa um desperdício líquido de dez vezes a quantidade de energia necessária para não executá-la.
+
+Para medir e quantificar a extensão da cegueira de execução com rigor científico, desenvolvemos um arcabouço experimental controlado, cujos dados e artefatos estão integralmente preservados no repositório do projeto. A bateria de testes primária submeteu um corpus de 500 problemas matemáticos e lógicos aleatórios (gerados com semente determinística 42 para reprodutibilidade total) à avaliação comparativa entre dois modos: a execução cega convencional e a compilação por necessidade sob o algoritmo ZCA.
+
+O corpus de 500 problemas foi estruturado em quatro famílias distintas de problemas, representativas de tarefas reais de engenharia e processamento de dados:
+
+1. **Somas com limiar e monotonicidade declarada (40% do corpus):** problemas de acumulação onde termos são adicionados até testar um limite, com garantia de não-negatividade dos operandos.
+2. **Incógnitas com limites e oráculo executável (30% do corpus):** equações e desigualdades onde variáveis possuem intervalos delimitados conhecidos a priori.
+3. **Incógnitas sem oráculo (20% do corpus):** problemas com informações incompletas onde a única resposta matematicamente válida e honesta é a declaração de incerteza (estado Z ou `UNKNOWN`).
+4. **Médias e estatísticas com dados ausentes (10% do corpus):** cálculos de agregados sob cenários de amostragem parcial.
+
+Os resultados quantitativos obtidos no teste de estresse de 500 problemas (registrados no arquivo `results/stress_results_500.json`) fornecem o retrato numérico do desperdício:
+
+* **Unidades de computação demandadas pela execução cega:** 3.784 unidades
+* **Unidades de computação efetivamente executadas sob ZCA:** 789 unidades
+* **Unidades de computação eliminadas com certificado:** 2.995 unidades
+* **Taxa de eliminação certificada:** 79,15%
+
+Cerca de quatro quintos de todas as operações aritméticas e lógicas solicitadas pela abordagem tradicional eram completamente dispensáveis para responder às perguntas sob os contratos especificados.
+
+Entretanto, uma análise de engenharia honesta não pode limitar-se a contabilizar operações eliminadas; deve incluir obrigatoriamente o custo de determinar que essas operações eram elimináveis. O processo de análise de necessidade exige a execução de verificações algébricas, avaliação de limites e geração de provas. Portanto, o benefício real trazido pela arquitetura deve ser medido pela equação do **NetBenefit computacional**:
+
+$$\text{NetBenefit} = C_{\text{baseline}} - \left( C_{\text{análise}} + C_{\text{resíduo}} + C_{\text{verificação}} \right)$$
+
+Onde $C_{\text{baseline}}$ representa o custo total da execução tradicional sem análise, $C_{\text{análise}}$ representa os ciclos despendidos pelo compilador ZCA na busca por um Decision Kernel, $C_{\text{resíduo}}$ é o custo do código que permanece estritamente necessário e $C_{\text{verificação}}$ é o custo de validar o certificado independente emitido.
+
+No experimento de 500 problemas, o NetBenefit agregado atingiu $+2.946,23$ unidades computacionais de saldo positivo. A imensa maioria dos problemas obteve ganhos expressivos. Todavia, a transparência científica exige expor os casos em que o saldo foi negativo. Nos 7 problemas que exigiram execução completa e nos 29 problemas que resultaram em `UNKNOWN`, o custo da análise $C_{\text{análise}}$ constituiu um custo adicional sem redução correspondente, gerando NetBenefit negativo. A análise de necessidade não é um milagre gratuito: é um investimento computacional que se paga quando a estrutura do problema contém redundância explorável, mas que representa um custo sobreposto quando o problema é irredutível.
+
+[FIGURA fig09_netbenefit_tradeoff]
+
+Para verificar se essa taxa de eliminação de ~79% e o NetBenefit positivo se sustentavam em larga escala, escalamos o experimento em duas ordens de grandeza adicionais. A bateria foi reexecutada para $N = 5.000$ problemas (`results/stress_results_5000.json`) e para $N = 500.000$ problemas (`results/stress_results_500000.json`), mantendo a mesma semente inicial 42.
+
+A tabela a seguir resume a evolução dos dados através das três ordens de grandeza:
+
+| Métrica de Desempenho | N = 500 | N = 5.000 | N = 500.000 |
+|---|---|---|---|
+| Unidades Originais Demandadas | 3.784 | 37.120 | 3.714.285 |
+| Unidades Executadas no Runtime | 789 | 9.032 | 872.374 |
+| Unidades Eliminadas com Prova | 2.995 | 28.088 | 2.841.911 |
+| Taxa de Eliminação Certificada | 79,15% | 75,67% | 76,51% |
+| NetBenefit Agregado (Unidades) | +2.946,23 | +27.617,49 | +2.794.817,81 |
+| Taxa de Eliminação Falsa | 0,0% | 0,0% | 0,0% |
+
+Os dados comprovam a estabilidade do fenômeno: em um universo de meio milhão de problemas, a taxa de eliminação estabiliza-se em 76,51%, e o NetBenefit acumulado ultrapassa 2,79 milhões de unidades poupadas.
+
+A cegueira de execução manifesta-se com ainda maior gravidade em coprocessadores especializados e caros, como aceleradores quânticos de nuvem (QPUs). Em um estudo empírico conduzido no repositório sobre a energia do estado fundamental da molécula de $H_2$ na base STO-3G ($d = 0,75\,\text{Å}$), preservado em `results/h2_energy_qpu_study.json`, o valor exato certificado do estado fundamental é $E_{\text{exato}} = -1,145599\,\text{Ha}$. Quando a mesma molécula foi submetida a um circuito variacional em hardware quântico real de 127 qubits, a estimativa obtida com 2.048 disparos por base foi de $E_{\text{QPU}} = -1,004784\,\text{Ha}$, apresentando um desvio de $+0,140815\,\text{Ha}$ devido ao ruído térmico e de leitura do dispositivo.
+
+Através do portão de pre-flight do compilador ZEPHIRUM, a pergunta "a energia do estado fundamental é menor ou igual a -1,10 Ha?" foi avaliada offline por redução exata antes da submissão. O compilador emitiu o veredicto verdadeiro com certificado algébrico em frações de milissegundo em CPU clássica, demonstrando que o consumo de tempo de hardware quântico para responder àquela pergunta específica sob aquele contrato era completamente desnecessário. O uso do hardware real é uma ferramenta valiosa de evidência empírica para testar limites de coerência física, mas jamais deve ser exigido quando o núcleo exato da teoria resolve a pergunta sem execução.
+
+## Nível 3: Para o cientista da computação
+
+A fundamentação teórica da eliminação de computações desnecessárias requer posicionar o algoritmo ZCA no espectro das disciplinas formais da ciência da computação. A busca por evitar trabalho computacional inútil atravessa décadas de literatura acadêmica, manifestando-se em múltiplos domínios independentes:
+
+1. **Fatiamento de Programas (Program Slicing):** Introduzido por Mark Weiser em 1981, o fatiamento estático e dinâmico computa o conjunto de instruções de um programa que podem afetar o valor de uma variável em um ponto de interesse. Embora o fatiamento reduza o grafo de fluxo de controle, ele opera estritamente sobre a sintaxe e a dependência de dados do programa, sem incorporar a tolerância do contrato ($\varepsilon$) ou a pergunta final ($Q$).
+2. **Avaliação Parcial (Partial Evaluation):** Desenvolvida na tradição das equações de Futamura e sistematizada por Jones, Gomard e Sestoft (1993), a avaliação parcial (conhecida como técnicas MIX) especializa um programa genérico $f(x, y)$ em relação a uma entrada estática $x$, gerando um programa otimizado $f_x(y)$. A avaliação parcial pré-calcula expressões constantes, mas não possui mecanismos para abortar a execução com base em limiares dinâmicos ou metas contratuais.
+3. **Interpretação Abstrata:** Proposta por Patrick e Radhia Cousot em 1977, formaliza a aproximação de semânticas operacionais sobre domínios abstratos (intervalos, poliedros). A interpretação abstrata permite provar a ausência de erros em tempo de compilação, mas seu propósito primário é a verificação de propriedades de segurança, não a geração de um executável residual mínimo.
+4. **Otimização Semântica de Consultas (Semantic Query Optimization):** Desenvolvida no contexto de bancos de dados relacionais (King, 1981), utiliza restrições de integridade declaradas no esquema para eliminar junções e varreduras de tabelas. Esta é a tradição histórica mais próxima do ZCA, distinguindo-se por operar em linguagens declarativas de dados e não em algoritmos gerais.
+
+A inovação da arquitetura ZEPHIRUM consiste na integração sintética dessas tradições em um pipeline unificado, onde a pergunta ($Q$), o contrato ($C$), o orçamento ($B$) e o modelo ($M$) formam um espaço de busca explícito para o **Decision Kernel**.
+
+Analisemos a distribuição de estados formais emitida pelo compilador ZCA no corpus de 500 problemas e no corpus ampliado de 500.000 problemas:
+
+```
+ Corpus N = 500:
+ ├── DECIDED_WITHOUT_EXECUTION:  292 (58,40%)
+ ├── DECIDED_BY_REDUCTION:        169 (33,80%)
+ ├── RESIDUAL_COMPUTATION_REQ:     3 (0,60%)
+ ├── FULL_EXECUTION_REQUIRED:      7 (1,40%)
+ └── UNKNOWN (Estado Z):          29 (5,80%)
+
+ Corpus N = 500.000:
+ ├── DECIDED_WITHOUT_EXECUTION:  265.832 (53,17%)
+ ├── DECIDED_BY_REDUCTION:       192.883 (38,58%)
+ ├── RESIDUAL_COMPUTATION_REQ:     2.706 (0,54%)
+ ├── FULL_EXECUTION_REQUIRED:      7.161 (1,43%)
+ └── UNKNOWN (Estado Z):          31.418 (6,28%)
+```
+
+A estabilidade das proporções entre $N=500$ e $N=500.000$ revela invariantes estruturais do modelo:
+
+1. **Dominância da Decisão sem Execução e por Redução:** Em ambos os regimes, mais de 91% dos problemas são resolvidos nos degraus superiores da análise (identidades algébricas, monotonicidade e redução de intervalo), sem necessidade de invocar o runtime.
+2. **Raridade do Resíduo Parcial:** A classe `RESIDUAL_COMPUTATION_REQUIRED` representa cerca de 0,5% a 0,6% do corpus. Isso ocorre porque a maioria das perguntas em domínios numéricos simples colapsa totalmente (0 ou 1) ou exige a avaliação integral do resíduo restante quando os limites são estreitos.
+3. **Garantia de Solidez (Soundness) e Imunidade a Ataques:** Em todas as 500.000 execuções, a taxa de eliminação falsa permaneceu rigorosamente em $0,0\%$. Além disso, nos testes de invasão de integridade, 20 certificados nos quais os valores de testemunho foram adulterados por injeção de bits foram submetidos ao verificador independente (`Checker`). Todos os 20 ataques foram detectados e rejeitados ($100\%$ de taxa de rejeição de forjamento), provando que a validação re-deriva os passos a partir das premissas primárias e não confia na declaração do gerador.
+
+Para acelerar a fase de análise e evitar gastar o orçamento de compilação $C_{\text{análise}}$ em problemas irredutíveis, incorporamos uma **Camada de IA Consultiva**, cujos resultados estão registrados no arquivo `results/ai_layer_results.json`. Treinamos um classificador probabilístico Naive Bayes sobre um ledger histórico de 40.000 compilações prévias e o testamos sobre um conjunto cego de 10.000 novos problemas.
+
+Os resultados quantitativos dessa camada preditiva revelam um padrão de desempenho fascinante:
+
+* **Acurácia Global do Modelo:** 95,67% (contra 53,05% do baseline de previsão da classe majoritária).
+* **Revocação (Recall) por Classe:**
+  * `DECIDED_BY_REDUCTION`: 100,0%
+  * `FULL_EXECUTION_REQUIRED`: 100,0%
+  * `DECIDED_WITHOUT_EXECUTION`: 94,2%
+  * `UNKNOWN` (Estado Z): 90,0%
+  * `RESIDUAL_COMPUTATION_REQUIRED`: **0,0%**
+
+A limitação registrada na última linha deve ser analisada com extrema honestidade científica. A camada heurística de IA falhou em identificar 100% dos casos pertencentes à classe de resíduo parcial (0,0% de revocação), classificando-os erroneamente entre redução completa ou execução integral. Essa falha ocorre porque a classe de resíduo representa apenas 0,5% dos dados de treinamento, tornando suas características estatísticas quase invisíveis para o classificador Naive Bayes sob a métrica de perda padrão.
+
+Esta limitação, no entanto, não compromete a solidez (soundness) do sistema. Na arquitetura ZEPHIRUM, a IA é estritamente consultiva: ela atua apenas como um conselheiro de orçamento de pré-compilação ("este problema parece exigir execução completa; deseja gastar recursos analisando-o?"). A decisão final de execução ou eliminação continua sendo emitida exclusivamente pelo motor determinístico ZCA e validada pelo Verificador Independente. A inteligência artificial propõe, mas a prova matemática dispõe.

book/capitulos/cap03_pt.md

@@ -0,0 +1,141 @@
+# Capítulo 3: HIPÓTESE: "Precisamos computar isto?"
+*ZEPHIRUM: A Computação Antes da Execução | Parte I: A Pergunta*
+
+## Nível 1: Para qualquer leitor
+
+Toda grande virada na história da engenharia e da tecnologia começou não com uma resposta mais rápida, mas com uma pergunta formulada de maneira diferente. Quando a engenharia aeronáutica buscou elevar os níveis de segurança dos voos comerciais nas últimas décadas, a solução primária não foi construir turbinas mais potentes para atravessar tempestades tropicais em velocidade máxima, mas desenvolver sistemas integrados de radar meteorológico e planejamento dinâmico de rotas capazes de responder, minutos antes, se era realmente necessário atravessar a tempestade em vez de contorná-la com consumo mínimo de combustível.
+
+Na computação moderna, travamos uma busca obsessiva e quase exclusiva por capacidade bruta de processamento. Construímos datacenters que consomem a energia elétrica equivalente à de metrópoles inteiras, projetamos chips de silício com centenas de bilhões de transistores e desenvolvemos arquiteturas de supercomputação exascale para executar volumes de cálculos cada vez mais avassaladores. Contudo, raramente paramos para fazer a pergunta fundacional que deveria anteceder todo e qualquer ciclo de instrução enviado ao processador:
+
+**"Eu realmente preciso executar esta computação para responder à pergunta que fiz sob o contrato estabelecido?"**
+
+Esta é a **Hipótese Central** que fundamenta este livro e a arquitetura ZEPHIRUM. Ela afirma com rigor que a execução física de um programa não deve ser o ponto de partida implícito e automático de um sistema computacional, mas apenas a última etapa, estritamente justificada e residual, de um processo sistemático e auditável de avaliação de necessidade.
+
+[FIGURA fig04_portao_trivalente]
+
+Para compreender intuitivamente a profundidade dessa inversão, imagine a rotina de inspeção estrutural de uma grande ponte rodoviária de concreto armado. Se a pergunta feita pelo departamento de infraestrutura for "a ponte suporta o tráfego seguro de um caminhão de 40 toneladas?", a equipe de engenharia civil não explode a ponte nem coloca cinquenta caminhões pesados sobre ela até que a estrutura comece a ceder para medir o ponto exato de colapso. Em vez disso, os engenheiros consultam as plantas estruturais, analisam as equações de resistência dos materiais, verificam os dados dos sensores de deformação já instalados e utilizam limites matemáticos conhecidos. Se a capacidade nominal calculada da estrutura é de 120 toneladas, a pergunta sobre o caminhão de 40 toneladas é respondida afirmativamente de imediato, por prova analítica e margem de segurança, sem submeter a ponte a nenhum teste destrutivo desnecessário.
+
+Na computação tradicional, agimos exatamente como um inspetor irresponsável que exigisse a carga máxima destrutiva para cada pergunta sobre a ponte. Quando escrevemos um programa imperativo tradicional em linguagens como C, Java ou Python para somar um vetor de um milhão de elementos, ordenar uma tabela de banco de dados ou simular a evolução temporal de uma molécula, o ambiente de execução tradicional aceita as instruções passivamente e as executa do primeiro ao último passo, sem jamais interrogar o compilador sobre o que o usuário realmente precisa saber com aquele resultado.
+
+A mudança de paradigma proposta nesta obra reorganiza o fluxo fundamental de pensamento:
+
+* **Paradigma Convencional (Centrado na Execução):** PROBLEMA $\to$ ALGORITMO $\to$ PROGRAMA $\to$ COMPILAÇÃO $\to$ EXECUÇÃO $\to$ RESULTADO
+* **Paradigma ZEPHIRUM (Centrado na Pergunta):** PROBLEMA $\to$ PERGUNTA $\to$ CONTRATO $\to$ ANÁLISE DE NECESSIDADE $\to$ DECISION KERNEL $\to$ CERTIFICADO $\to$ RESÍDUO NECESSÁRIO $\to$ EXECUÇÃO
+
+Sob essa perspectiva, três perguntas norteadoras orientam cada decisão de projeto desenvolvida nesta obra:
+
+1. Eu realmente preciso executar esta computação para responder à pergunta que fiz?
+2. Se preciso computar, qual é a menor computação que consigo justificar perante o contrato?
+3. Como provar matematicamente que aquilo que foi eliminado realmente não era necessário?
+
+Se a resposta à primeira pergunta for "não", o sistema computacional tem o dever de emitir a resposta correta de imediato, acompanhada de uma prova de que a execução integral era dispensável sob as premissas estabelecidas.
+
+## Nível 2: Para o cientista e o engenheiro
+
+Para converter uma proposta conceitual em uma arquitetura de engenharia de software funcional e mensurável, a hipótese de necessidade precisa ser formalizada matematicamente. No coração dessa formalização está o conceito de **Contrato de Necessidade** ($C$).
+
+Um contrato $C$ não se limita a especificar os tipos de dados de entrada e saída como nas interfaces de programação convencionais. Ele é definido formalmente como uma tupla estrita de cinco elementos:
+
+$$C = \left( Q, \varepsilon, B, \mathcal{H}, \mathcal{R} \right)$$
+
+Onde:
+* $Q$ representa a **Pergunta** ou predicado lógico a ser decidido (por exemplo: "o valor acumulado de $X$ ultrapassa a margem $Y$?");
+* $\varepsilon$ representa a **Tolerância a Erro** ou margem de incerteza aceitável declarada pelo usuário ($\varepsilon \ge 0$);
+* $B$ representa o **Orçamento de Recursos** limite (tempo máximo de CPU/GPU, cota de memória RAM, limite financeiro em nuvem ou número máximo de disparos em hardware quântico);
+* $\mathcal{H}$ representa o conjunto de **Hipóteses e Invariantes** válidas a priori no domínio (por exemplo: "todos os operandos do vetor pertencem ao conjunto dos inteiros não negativos");
+* $\mathcal{R}$ representa as **Restrições de Contexto** que precisam ser preservadas incondicionalmente durante o processo.
+
+Na sintaxe declarativa da linguagem ZEPHIRUM (ZYQL), o programador expressa essa tupla por meio de blocos explícitos de alto nível:
+
+```zephirum
+ASK Q: sum(transactions) > 100.0;
+CONTRACT {
+  tolerance: 0.0;
+  budget: 1000_units;
+  assumptions: [non_negative(transactions)];
+  require: certified_proof;
+}
+```
+
+Outro exemplo emblemático de redução em nível de engenharia é o cálculo do determinante de uma matriz triangular de dimensão $N \times N$. Na abordagem ingênua por eliminação gaussiana ou expansão por cofatores, a computação exige entre $O(N^3)$ e $O(N!)$ operações em ponto flutuante. Contudo, quando o contrato declara a hipótese de que a matriz é triangular superior ($\mathcal{H} = \{\text{is\_upper\_triangular}(A)\}$), o compilador ZCA aplica a regra de redução do Degrau 1: o determinante é rigorosamente igual ao produto dos elementos da diagonal principal ($\det(A) = \prod_{i=1}^N a_{ii}$). A complexidade cai de $O(N^3)$ para $O(N)$ multiplicações simples, com tolerância $\varepsilon = 0,0$ e certificado exato, economizando mais de 99,99% dos ciclos de processamento para matrizes de grande porte.
+
+Além disso, o parâmetro de orçamento $B$ desempenha o papel vital de limitador de análise. Caso uma prova algébrica nos degraus superiores da escada se revele excessivamente dispendiosa em termos de tempo de análise, ultrapassando o teto fixado por $B$, o compilador aborta imediatamente a busca simbólica e transita com segurança para o estado $Z$ (`UNKNOWN`) ou despacha o problema para a execução residual direta, garantindo que o custo de pré-compilação $C_{\text{análise}}$ jamais exceda os limites contratuais declarados pelo usuário.
+
+Com o contrato $C$ devidamente instanciado, a etapa de compilação deixa de ser uma tradução direta para instrução de máquina e assume o papel de executar o **Algoritmo ZCA (Necessity Compilation Algorithm)**. O algoritmo ZCA é estruturado sob uma **escada rigorosa de 11 degraus de avaliação de necessidade**, ordenados de forma estrita pelo custo computacional crescente:
+
+[FIGURA fig03_escada_zca]
+
+1. **Degrau 1: Identidades Algébricas.** Examina se a resposta decorre diretamente de propriedades neutras, nulas ou determinísticas da álgebra (por exemplo: $A \cdot 0 = 0$, $A \cdot A^{-1} = I$, $\sin^2(x) + \cos^2(x) = 1$, $\det(I) = 1$). Se aplicável, a pergunta é decidida no Degrau 1 com custo de execução nulo.
+2. **Degrau 2: Invariantes de Domínio.** Avalia monotonicidade, posicionado de limites e monotonicidade acumulada (por exemplo: se $x_i \ge 0$, então $\sum_{i=1}^n x_i \ge \max(x_i)$).
+3. **Degrau 3: Simplificação de Expressão.** Aplica redução simbólica de termos constantes, eliminação de subexpressões comuns e dobramento de constantes (constant folding).
+4. **Degrau 4: Redução de Intervalo.** Determina os limites inferior ($\text{LB}$) e superior ($\text{UB}$) das variáveis do problema por meio de aritmética de intervalos. Se o intervalo $[\text{LB}, \text{UB}]$ estiver completamente contido dentro ou fora da região de decisão definida por $Q$, a resposta é emitida imediatamente.
+5. **Degrau 5: Análise de Limites.** Estuda o comportamento assintótico das funções envolvidas quando parâmetros tendem a extremos ou infinitos ($\lim_{n \to \infty} f(n)$).
+6. **Degrau 6: Solução Analítica em Forma Fechada.** Tenta resolver simbolicamente a equação, somatoria ou integral através de métodos algébricos exatos.
+7. **Degrau 7: Aproximação Certificada.** Utiliza expansões polinomiais truncadas (como séries de Taylor ou Chebyshev), garantindo via resto de Lagrange que o erro supremo da aproximação seja estritamente menor ou igual à tolerância $\varepsilon$ declarada no contrato.
+8. **Degrau 8: Algoritmo Clássico Determinístico.** Executa o procedimento algorítmico clássico mínimo otimizado em arquitetura CPU monothread.
+9. **Degrau 9: Paralelização em CPU/GPU.** Distribui o resíduo estritamente necessário sobre múltiplos núcleos de processamento ou aceleração vetorial em GPU.
+10. **Degrau 10: Simulação Estocástica / Monte Carlo.** Apela a amostragem probabilística e métodos estocásticos quando a solução determinística é intratável, mas o contrato tolera erro estatístico $\varepsilon$.
+11. **Degrau 11: Computação Quântica / Co-processadores Especializados.** Submete o resíduo final a unidades de processamento quântico (QPUs) ou aceleração exótica, exclusivamente quando todos os dez degraus anteriores se demonstrarem insuficientes para decidir a pergunta dentro do orçamento $B$.
+
+O mecanismo operacional decisivo da escada ZCA é a **saída antecipada**: o compilador percorre os degraus em ordem estrita do mais barato para o mais caro. No momento exato em que um degrau obtém evidência suficiente para decidir a pergunta $Q$ respeitando a tolerância $\varepsilon$, a travessia é interrompida, o **Decision Kernel** é gerado e o resultado é retornado sem avançar para os degraus mais caros.
+
+Para exemplificar a atuação do Degrau 11 e a honestidade na gestão de recursos físicos reais, examinemos a bateria experimental com a **escada de estados emaranhados GHZ (Greenberger-Horne-Zeilinger)** preservada no repositório através de múltiplos recibos auditáveis (`results/ghz3_fusion_ibm_fez.json`, `results/ghz_n_ladder_ibm_fez.json`, `results/ghz8_12_ladder_receipt.json`, `results/ghz20_sparse_ibm_fez.json` e `results/ghz_cross_hardware_bootstrap.json`).
+
+No estudo, analisou-se a presença de emaranhamento multiqubit em estados GHZ preparados para tamanhos $N \in \{2, 3, 4, 6, 8, 12, 20\}$ qubits. Antes de enviar qualquer comando a hardware quântico real de 127 qubits em nuvem, a pergunta $Q = \text{"o estado preparado apresenta emaranhamento genuíno de N corpos?"}$ foi processada offline pelo compilador ZEPHIRUM. O núcleo exato provou a presença de emaranhamento com veredicto $1$ e emitiu os certificados pré-flight correspondentes (como o hash `f749001a...` para GHZ-3 e `0c4173ae...` para GHZ-8) em tempo clássico desprezível, sem consumir segundos de hardware.
+
+Quando os mesmos circuitos foram posteriormente despachados para hardware quântico real com o objetivo de obter validação empírica de decorrelação física, os dados registraram a seguinte curva de degradação da população ideal nos polos $|0^N\rangle + |1^N\rangle$:
+
+[FIGURA fig10_escala_ghz_ladder]
+
+* **GHZ-3 (3 qubits):** 97,9% de população nos polos em hardware real
+* **GHZ-4 (4 qubits):** 95,1% de população nos polos
+* **GHZ-6 (6 qubits):** 91,8% de população nos polos
+* **GHZ-8 (8 qubits):** 72,5% de população nos polos (com $\langle Z_0 Z_7 \rangle = 0,9062$)
+* **GHZ-12 (12 qubits):** 53,5% de população nos polos (com $\langle Z_0 Z_{11} \rangle = 0,7540$)
+* **GHZ-20 (20 qubits, representação *sparse*):** 39,7% de população nos polos (com 72,3% dos disparos situados a uma distância de Hamming $\le 2$ dos polos)
+
+Em paralelo, os testes de controle negativo com estados separáveis (como o estado $|+0\dots0\rangle$) apresentaram veredicto exato $0$ offline e obtiveram correlações nulas em hardware real ($\langle ZZ \rangle \approx 0,0508$, com intervalos de confiança de 95% contendo o zero). Estes dados empíricos demonstram a precisão da separação: a decisão teórica certified ocorre offline sem custo de hardware, enquanto a execução física no chip atua como instrumento de calibração e evidência complementar.
+
+## Nível 3: Para o cientista da computação
+
+Formulamos agora a definição rigorosa do objeto conceitual e prático fundamental desta obra: o **Decision Kernel**.
+
+**Definição 3.1 (Decision Kernel, $K$).** Dado um problema $P$, uma pergunta $Q$ e um contrato $C = (Q, \varepsilon, B, \mathcal{H}, \mathcal{R})$, um *Decision Kernel* $K$ é um procedimento computacional acompanhado de um certificado de verificação $\Pi$, suficiente para decidir a validade do predicado $Q$ sob o contrato $C$, obtido no menor degrau de custo acessível dentro do catálogo de transformações do compilador.
+
+É imperativo reiterar um compromisso de **honestidade intelectual e limitação teórica**: a arquitetura ZEPHIRUM **não reivindica a minimalidade global absoluta** do Decision Kernel no sentido da Complexidade de Kolmogorov ou do Teorema de Rice. Demonstrar a minimalidade global de um programa para um problema genérico é um problema comprovadamente indecidível. O que o algoritmo ZCA garante é a **minimalidade relativa certified dentro do espaço de regras de simplificação, identidades e reduções disponíveis no motor de compilação**.
+
+Do ponto de vista da semântica operacional, a execução do ZCA resulta na emissão de um entre cinco estados formais bem definidos, que determinam o destino da computação:
+
+1. **`DECIDED_WITHOUT_EXECUTION` (Veredito 0/1 Puro):** A pergunta foi resolvida por prova algébrica ou limite nos degraus 1 a 6. O Decision Kernel é a própria prova $\Pi$. O resíduo computacional é nulo ($R = \emptyset$). Nenhuma instrução do código original é despachada para o runtime.
+2. **`DECIDED_BY_REDUCTION` (Redução Parcial):** O compilador transformou a expressão original $P$ em uma representação reduzida $P'$, eliminando os componentes que não afetam a decisão. O resíduo $R = P'$ é executado no runtime para obter a resposta final.
+3. **`RESIDUAL_COMPUTATION_REQUIRED` (Resíduo Mínimo):** Uma fração residual e irredutível do algoritmo precisou ser executada para resolver o predicado dentro da tolerância $\varepsilon$.
+4. **`FULL_EXECUTION_REQUIRED` (Execução Integral Justificada):** Nenhuma redução certificada foi encontrada nos degraus de análise; a execução integral do algoritmo é comprovadamente necessária e justificada sob o modelo $M$.
+5. **`UNKNOWN` (Estado Z / Zephirum):** O compilador não obteve evidências nem orçamento suficientes para provar necessidade ou desnecessidade. O estado $Z$ é mantido como a representação formal da dúvida não colapsada.
+
+Para relacionar esta estrutura à ciência da computação teórica contemporânea, vale contrastar a abordagem do recibo ZEPHIRUM com a tradição clássica de **Proof-Carrying Code (PCC)** formulada por George Necula em 1997. No paradigma PCC, o produtor de código envia o binário acompanhado de uma prova formal de segurança (por exemplo, que o programa jamais efetuará acessos fora dos limites da memória RAM ou violará políticas de tipos). No paradigma ZEPHIRUM, por outro lado, o recibo assinado não certifica apenas propriedades de *segurança* (safety), mas propriedades de **suficiência e necessidade computacional** sob a pergunta $Q$ e a tolerância $\varepsilon$.
+
+[FIGURA fig05_pipeline_certificacao]
+
+No repositório do projeto, os recibos de certificação (como os registrados nos arquivos `results/chsh_qkd_kingston.json`, `results/ghz20_sparse_ibm_fez.signed.json` e `results/hybrid_boundary_receipt.signed.json`) empregam o algoritmo de assinatura pós-quântica **ML-DSA-44** (FIPS 204).
+
+A estrutura JSON formal de um recibo assinado preserva os metadados completos da decisão:
+
+```json
+{
+  "algorithm": "ML-DSA-44",
+  "fips": "204",
+  "public_key": "br3zddcNuabHRG8vNmvHB2qklH5MG0UdYDWL2UrztkhuyuMYqsww5ccYJZgGzHoJw...",
+  "receipt": {
+    "document": "ZEPHIRUM hardware receipt",
+    "date_utc": "2026-10-09T00:56:06.945887Z",
+    "exact_verdict": 1,
+    "input_hash": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "certificate_trace": "RECURSIVE_SPARSE_SUPPORT_CHECK"
+  },
+  "signature": "7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b..."
+}
+```
+
+A independência arquitetural entre o **Gerador de Certificados** (integrado ao compilador) e o **Verificador Independente (Checker)** é o pilar de integridade do sistema. O Verificador não confia nas alegações do compilador: ele recebe o programa original, o recibo e a chave pública ML-DSA-44, re-deriva autonomamente todas as etapas de redução matemática a partir das premissas primárias e valida a assinatura criptográfica.
+
+Essa separação estrita é o que fundamenta os resultados de imunidade apresentados no Capítulo 6: quando 20 certificados propositadamente adulterados por alteração de bits foram submetidos ao Verificador, todas as 20 tentativas de forjamento foram identificadas e rejeitadas imediatamente (100% de taxa de detecção). A hipótese de computar apenas o necessário deixa de ser uma mera intenção de otimização de software e se consolida como uma garantia provada, mensurável e criptograficamente auditável na ciência da computação.