Elton José logo
Elton José
Verificação Formal

AlphaProof Code: Verificação Formal Agêntica E O Limite Do 'Passou No Teste'

AlphaProof Code: Verificação Formal Agêntica E O Limite Do 'Passou No Teste'
0 visualizações
20 minutos de leitura
#Verificação Formal

AlphaProof Code: Verificação Formal Agêntica E O Limite Do 'Passou No Teste'

Tem uma frase que eu escrevo e leio em revisão de pull request quase todo dia: "passou no teste". Ela aparece no comentário do PR, na descrição do commit, na mensagem do agente que terminou a tarefa. E toda vez que leio, sei que ela diz menos do que parece. Diz que os casos que alguém imaginou se comportaram como esse alguém esperava. Não diz nada sobre o caso que ninguém imaginou, que costuma ser justamente o que vira incidente.

Foi com essa frase na cabeça que li, na semana passada, o anúncio do AlphaProof Code, publicado pela Google DeepMind em 10 de novembro. A manchete que circulou foi algo como "IA prova que o Signal é seguro". Fui atrás do paper técnico, do repositório e do site de artefatos, porque essa manchete, do jeito que estava, me pareceu grande demais. E de fato é: o que foi feito é impressionante, mas é bem mais específico e bem mais interessante do que "o Signal é seguro".

Preciso deixar claro o que este texto é. Não rodei o AlphaProof Code, não compilei as provas e não tenho experiência prática com Lean em produção. Tudo o que está aqui vem da leitura dos dois posts da DeepMind, do paper técnico, do README do repositório público e de algumas matérias de imprensa, todos de 10 a 12 de novembro. O post é de 18 de novembro. Quando um número for da DeepMind, digo que é da DeepMind, e quando o post de blog e o paper discordarem, e eles discordam em pelo menos um ponto, registro a divergência.

O caminho é este: o que foi anunciado e o que o paper diz; a diferença mecânica entre teste, propriedade e prova; onde fica a confiança quando agentes escrevem as provas, onde o humano entra e o que ficou de fora; e, por fim, o que um time comum pode levar disso hoje, e por que conversa com Spec-Driven Development.


O Que A DeepMind Anunciou, E O Que O Paper Diz De Fato

O AlphaProof Code é descrito pela DeepMind como um framework agêntico de verificação formal que combina especialistas humanos com agentes de IA. A demonstração foi o código criptográfico central do protocolo Signal, usado no app Signal e, segundo a DeepMind, no Google Messages. A empresa afirma que é a primeira vez que a implementação de um protocolo amplamente usado desse tipo é verificada formalmente por qualquer método. É afirmação da própria empresa, sem avaliação independente nas matérias que li.

Os números centrais vêm do paper, que é mais preciso que o post de blog. O alvo é o código Rust não modificado do libsignal-protocol na versão 0.105.4 e do spqr na versão 1.6.0, compilado com rustc 1.98.1 de prateleira, estaticamente ligado com musl, gerando um executável AArch64 para Linux. Esse executável é um pequeno harness de linha de comando, o libsignal-cli, com três operações verificadas: init, send e recv. O código verificado tem cerca de 560 KB, ou aproximadamente 140 mil instruções AArch64. O resumo do paper fala em "cerca de 6,5 milhões de linhas de prova Lean verificadas por máquina", das quais cerca de 5,3 milhões são sobre o binário.

Aqui está a primeira divergência que vale registrar. O corpo do post de blog fala em "mais de seis milhões de linhas de Lean", o que bate com o paper. Mas a descrição da mesma página, aquela que aparece em compartilhamentos, fala em "mais de três milhões". O paper e o site de artefatos não mencionam três milhões em lugar nenhum. Fico com os 6,5 milhões do paper, e anoto que quem leu só o card de compartilhamento ficou com um número que é metade do real.

O prazo também vem bem documentado. Segundo o paper, o trabalho de prova foi feito por um time de cinco pessoas ao longo de quatro semanas, cada uma rodando agentes na própria estação de trabalho, e nenhum dos autores escreveu código de prova. As provas foram produzidas por times de agentes rodando o Gemini 4 Carbon. Na etapa de especificação, o paper cita agentes rodando Gemini 4 Carbon e Claude Opus 5.5, com revisores de uma família de modelos diferente da do autor da spec. Uma campanha típica, segundo o texto, coloca de 40 a 80 agentes numa única máquina por 24 a 72 horas.

Os artefatos estão públicos. O repositório google-deepmind/code-verification no GitHub está sob Apache 2.0 (o libsignal mantém a AGPL-3.0 original), e o README diz que checar as provas leva várias horas e de 15 a 34 GiB de RAM de pico. O que não está público é o AlphaProof Code como ferramenta: foram abertas as specs e as provas, não o sistema de agentes. O custo computacional não foi divulgado, e, segundo a cobertura que cita a WIRED, o próprio Google disse que ainda não está claro o quanto isso é prático em escala.

A notícia também se distorceu no caminho. O 9to5Mac titulou que a análise "prova que a criptografia do Signal e do WhatsApp é segura" e escreveu que a verificação garante que "não há situação em que o protocolo vá falhar". Nenhuma das duas coisas está no paper: o WhatsApp não foi analisado, e a lista do que ficou fora do escopo é longa. A distância entre paper e manchete é, em si, um bom exemplo do tema deste post.


Teste, Propriedade E Prova: Três Níveis De Garantia

Para entender por que isso importa, vale separar três coisas que no dia a dia a gente costuma chamar de "testar". Um teste unitário é uma afirmação sobre um exemplo: para esta entrada, espero esta saída. Ele é concreto, barato e cobre exatamente o que foi escrito. Um teste baseado em propriedade, no estilo QuickCheck ou Hypothesis, é uma afirmação sobre todas as entradas, verificada por amostragem: para qualquer lista, ordenar duas vezes dá o mesmo que ordenar uma, e o framework gera algumas centenas de listas tentando quebrar isso. Ele cobre muito mais terreno, mas continua sendo amostra.

Uma prova formal é a mesma afirmação sobre todas as entradas, só que demonstrada em vez de amostrada. Não existe o caso que o gerador não sorteou, porque não há sorteio. Em Lean, isso funciona porque a afirmação é um tipo e a prova é um termo desse tipo, e um núcleo pequeno do sistema, o kernel, checa se o termo tem mesmo aquele tipo. Se o kernel aceita, a afirmação vale, dentro do modelo em que foi escrita. Essa última cláusula é a que manchetes costumam esquecer.

Um esboço ajuda a ver a diferença de forma. É ilustrativo, não compilei, e o exemplo é deliberadamente trivial:

def clamp (lo hi x : Nat) : Nat := max lo (min hi x)

-- Teste: um exemplo, checado por avaliação
example : clamp 0 10 42 = 10 := by decide

-- Propriedade provada: vale para todo lo, hi, x, desde que lo ≤ hi

theorem clamp_le_hi (lo hi x : Nat) (h : lo ≤ hi) :
    clamp lo hi x ≤ hi := by
  unfold clamp
  omega

O example é o equivalente a um teste unitário. O teorema afirma que o resultado nunca passa de hi, para qualquer entrada, com a hipótese h explícita. Se alguém mudar clamp de um jeito que quebra a propriedade, a prova deixa de compilar: não é um teste vermelho num cenário, é o build quebrando porque a garantia deixou de valer. E a hipótese é parte da afirmação. Se lo > hi, o teorema não diz nada, e isso é escolha de quem escreveu a especificação.

O trabalho da DeepMind leva essa ideia a um extremo que, segundo a própria empresa, historicamente tomava anos de equipes especializadas. As propriedades são sigilo direto, segurança pós-comprometimento, autenticação, sigilo do handshake e confidencialidade e autenticidade de mensagens, provadas não sobre o código-fonte, mas sobre o binário. O paper tem dois cenários: um modelo simbólico, no estilo Dolev-Yao, com dez teoremas, e um modelo computacional, com um limite concreto para a vantagem de um atacante clássico.

O que mais me chamou atenção é o que a escolha do binário tira da base confiável. Segundo o paper, nem o código Rust nem o compilador são confiáveis no argumento. Se o rustc introduzir um comportamento estranho numa otimização, a prova sobre o binário pega, porque fala do que o processador executa, não do que o programador escreveu. É isso que separa este trabalho de uma análise de protocolo no papel.


Onde Está A Confiança: Gatekeeper, Hooks E A Base Confiável

Se agentes escrevem milhões de linhas de prova e nenhum humano escreveu código de prova, a pergunta óbvia é por que alguém deveria confiar no resultado. A resposta curta do paper é: você não confia nos agentes, confia no checador. O diagrama da DeepMind chama os agentes de "time de provadores não confiáveis" e coloca entre eles e o resultado um "gatekeeper confiável". Esse gatekeeper guarda uma cópia somente-leitura da especificação e usa a ferramenta comparator do Lean. Ele só aceita uma prova se o enunciado bater exatamente com a spec, se só axiomas padrão forem usados e se o kernel aceitar. O paper cita que sorry, o atalho do Lean para "confie em mim", e native_decide, que delega parte da checagem a código compilado, são rejeitados.

Essa arquitetura torna o volume irrelevante para a confiança. Seis milhões e meio de linhas de prova seriam ilegíveis para qualquer humano, mas não precisam ser lidas. O que precisa ser lido é o lado confiável da fronteira, e o paper é honesto sobre o tamanho dele: cerca de 18 mil linhas de enunciados e definições, cerca de 26 mil contando a semântica AArch64, que modela 467 instruções e 31 chamadas de sistema do Linux em modo usuário.

Uma parte dessa base merece atenção: os hooks. Algumas rotinas não são provadas contra o código real, são substituídas por contratos. O paper fala em 39 rotinas, o site de artefatos em 37, mas o perfil é o mesmo: primitivas criptográficas, funções de memória e string da libc, escrita em arquivo e saída padrão, algumas rotinas da biblioteca Rust. Ou seja, a implementação do X25519 ou do AES em si não é provada; assume-se que ela respeita um contrato. É uma escolha razoável e comum, mas significa que "verificado até o código de máquina" tem um asterisco do tamanho de uma biblioteca de criptografia.

Somam-se a isso as hipóteses criptográficas, que nenhuma prova de software elimina: Gap-DH, infalsificabilidade do XEdDSA, resistência a colisão do Kyber1024, segurança do HKDF e do HMAC, entre outras. No modelo simbólico, a criptografia é tratada como perfeita. Isso não é defeito, é o estado da arte de prova de protocolo. Mas é a diferença entre "o Signal é seguro" e "este binário satisfaz estas propriedades sob estas hipóteses", que é o que foi provado.

O que eu tiro dessa seção, como arquiteto, é uma pergunta que vale para qualquer sistema com agentes no meio: onde está a fronteira entre o que é gerado e o que é confiável, e quão pequeno é o lado confiável? No AlphaProof Code, a fronteira é um kernel de prova e algumas dezenas de milhares de linhas revisadas por humanos. Na maioria dos pipelines de código com agentes que vejo descritos hoje, a fronteira é uma suíte de testes que o próprio agente pode editar. Já escrevi sobre esse problema em o mecanismo pelo qual agentes apagam ou enfraquecem testes, e a resposta da DeepMind a ele é estrutural: o gatekeeper tem a spec em modo somente-leitura, e um agente crítico só aprova emendas à spec que sejam necessárias, pequenas e que não enfraqueçam a segurança.


Onde O Humano Entra: A Spec É O Trabalho

O número que mais circulou depois dos 6 milhões foi o de 1%. O post de blog da DeepMind diz que os agentes marcaram para uma segunda olhada humana "apenas um por cento da base de código", e chama isso de enorme economia de tempo. É um número da DeepMind, e eu não encontrei a mesma cifra no paper. Mais importante que a cifra, porém, é o que ela mede: a revisão humana dos trechos sinalizados pelos agentes, não o esforço humano total. E o paper é bem claro sobre onde esse esforço total foi parar.

A frase que mais me marcou no paper é esta: "a maior parte do nosso esforço não foi para as provas, mas para as especificações". Em outro trecho, os autores dizem que a maior parte do esforço humano em verificação de software agora está em engenharia de especificação. Os humanos escolhem o que provar, resolvem ambiguidades, avaliam trade-offs de segurança e tomam todas as decisões finais. O usuário revisa, corrige e aprova a especificação antes de qualquer prova ser escrita, e o commit git dessa aprovação vira a linha de base. O paper também admite que "monitorar o time tomou muito tempo humano". Ou seja, o 1% é real dentro do seu recorte, mas o recorte não é o projeto.

O processo de especificação é, para mim, a parte mais reaproveitável. Um agente rascunha os enunciados de topo, adaptados de modelos já publicados sobre o Signal, sob orientação humana. Revisores de outra família de modelos checam fidelidade, força e consistência. Há checagens de vacuidade, porque um teorema com hipóteses impossíveis é verdadeiro e inútil, e testes de mutação, como pular a verificação do MAC e conferir que a propriedade quebra. E os autores registraram todo ponto em que os enunciados em Lean se afastam das referências ou do próprio libsignal.

O teste mais convincente do trabalho, para mim, foi o de reintroduzir bugs. A equipe pegou duas falhas reais, já corrigidas no histórico do libsignal, e as recolocou numa cópia isolada. Uma envolvia o armazenamento de estado de uma nova sessão durante uma tentativa de decifração de mensagem de prekey, incluindo uma cópia do segredo do signed prekey. A outra era a ausência de checagem de que a chave base X25519 do iniciador está no subgrupo correto. Nos dois casos, o sistema produziu uma prova verificada por máquina de que a versão com bug viola o teorema simbólico. Isso responde a uma objeção importante: a spec não é tão fraca a ponto de aceitar qualquer código. O paper nota que o teorema computacional não pode ser refutado do mesmo jeito, porque isso exigiria quebrar as próprias hipóteses criptográficas.

Há um subproduto que considero quase tão relevante quanto o resultado principal. Ao formalizar especificações que partiam de análises anteriores publicadas, os autores registram cerca de 15 lacunas ou bugs na análise computacional existente do Double Ratchet e vários erros em consultas ProVerif simbólicas que precisaram ser corrigidos. Não são bugs no Signal. São bugs em especificações escritas por especialistas e revisadas por pares. Esse é o lembrete de que a spec é código, tem bug como código e precisa de revisão como código.

Isso conecta com o post sobre a Scion e a revisão por intenção em vez de por diff. Quando o volume gerado passa do que um humano consegue ler, a revisão precisa subir de nível: ler o que foi pedido, não o que foi feito. O AlphaProof Code é a versão mais radical disso que já vi documentada. Ninguém lê as 6,5 milhões de linhas; quem importa lê as 18 mil.


O Que Ficou De Fora

Uma leitura honesta do resultado precisa passar pela lista do que não foi provado, e o paper é generoso nessa lista. Só sessões um-para-um estão cobertas; mensagens em grupo ficam para trabalho futuro. Estado multi-dispositivo está fora. A cura pós-quântica do SPQR não está coberta, e nos teoremas do ratchet o atacante pode escolher as chaves do SPQR. O limite computacional vale apenas contra atacantes clássicos, sem garantia contra adversários quânticos. A geração de chaves, a operação keygen, não foi verificada. Canais laterais, como tempo e consumo de energia, estão fora do escopo.

O cenário simbólico é estreito de propósito: duas partes, um signed prekey, no máximo um prekey de uso único. No modelo computacional, os termos estatísticos ficam vazios a partir de cerca de 25 mil mensagens numa única sessão. O ambiente modelado tem relógio e aleatoriedade fixos, memória e pilha limitadas, e a semântica não modela threads, sinais, ligação dinâmica nem arquivos fora do diretório corrente.

E há a questão de plataforma. O resultado vale para o build Linux com musl. Os apps Android e iOS não foram verificados; o paper argumenta que o resultado se transfere se as diferenças de build e de sistema preservarem o comportamento do código do protocolo, o que é argumento, não prova. A imprensa que entrevistou a equipe registra mais dois pontos: a DeepMind partiu de trabalho prévio de verificação formal do Signal, então as quatro semanas não são um projeto do zero, e o custo não foi divulgado.

Nada disso diminui o feito; para quem conhece verificação formal, essa lista é sinal de seriedade. Mas ela mostra o limite da prova pelo mesmo ângulo que mostra o limite do teste. Um teste diz "funciona para estes casos". Uma prova diz "funciona para todos os casos dentro deste modelo, sob estas hipóteses". O "passou no teste" esconde quais casos; o "foi provado" pode esconder qual modelo. Swarat Chaudhuri, pesquisador da DeepMind, disse à imprensa que ainda há "um longo caminho" até escalar isso para todo o software do mundo, e acho que é a frase certa para guardar.


O Que É Realista Para Um Time Comum Hoje

Se você trabalha num time de produto comum, a pergunta prática não é se vai verificar o seu monólito em Lean na próxima sprint. Não vai, e o paper não sugere isso. A ferramenta de agentes não está disponível, o custo computacional não foi divulgado e o build das provas públicas pede dezenas de GiB de RAM e horas de máquina. O que dá para levar é a estrutura do raciocínio, que funciona em degraus bem mais baixos.

O primeiro degrau é escrever propriedades em vez de só exemplos. Toda base de código tem invariantes que, se quebrarem, viram incidente: um saldo que nunca fica negativo sem autorização, a idempotência de um webhook, uma transição de estado que nunca pula etapa. Testes baseados em propriedade, com Hypothesis, fast-check ou equivalentes, transformam isso em afirmações sobre todas as entradas, checadas por amostragem. Não é prova, mas muda a pergunta de "este caso funciona?" para "isto sempre vale?", e uma propriedade é bem mais difícil de satisfazer trapaceando do que um exemplo fixo.

O segundo degrau é tratar a especificação como artefato versionado e protegido. A lição mais transferível do AlphaProof Code nem é a prova, é a separação de papéis: quem escreve a spec não é quem escreve a implementação, a spec é aprovada antes do código, fica em modo somente-leitura para o agente implementador e qualquer mudança passa por um crítico que pergunta se ela enfraquece a garantia. Dá para fazer isso hoje com uma suíte de propriedades num diretório que o agente não pode editar, protegida por CODEOWNERS e por uma checagem de CI que falha se os arquivos de spec mudaram no mesmo PR da implementação.

O terceiro degrau é verificação formal de verdade, mas em núcleos pequenos e críticos. Ferramentas como Lean, Dafny e Verus existem, e o custo de escrever provas é exatamente o que agentes começam a baratear. Um cenário hipotético: um time de pagamentos com uma função de conciliação de 300 linhas que já causou dois incidentes. Especificar que a soma dos lançamentos fecha e que nenhuma transação é contada duas vezes, e deixar um agente tentar provar, é um experimento de escopo controlado. Se a prova não sai, a falha costuma apontar um caso de borda. Não tenho dado de que isso funcione bem fora do contexto da DeepMind; digo só que é o tamanho certo de aposta. Vale lembrar também o que discuti sobre o Harness 2 e agentes que reescrevem o próprio harness: quanto mais autonomia o agente tem sobre o ambiente, mais importa que o checador final fique fora do alcance dele.

É aqui que entra a ponte com Spec-Driven Development. No mapa de ferramentas de SDD e da spec como contrato executável, a ideia central era que a spec precisa ser algo que a máquina consegue checar, não só um documento que o agente lê. Spec como texto estruturado ajuda o agente a entender a intenção, mas não o impede de entregar algo que viola a intenção e passa no teste. O AlphaProof Code mostra a outra ponta: a spec é um enunciado formal, e "pronto" significa que um checador independente aceitou a prova. Entre texto livre e teorema em Lean há muitos pontos intermediários, e propriedades executáveis são o mais acessível.

Há um risco que vale nomear, e ele aparece no próprio paper. Se a especificação vira o lugar onde está todo o valor, ela vira também o lugar onde está todo o risco. Uma spec fraca provada é pior que uma spec fraca testada, porque gera uma confiança que não merece. É por isso que vacuidade, mutação e bugs reintroduzidos importam tanto no trabalho da DeepMind. E é por isso que a ideia de dívida cognitiva sobre código gerado por IA não some com a verificação formal; ela muda de lugar. Você pode não entender as provas, e tudo bem, mas precisa entender a spec muito bem, porque é a única parte que ninguém vai checar por você.


Conclusão

Saí da leitura do paper com a sensação de que o resultado mais importante não é o número de linhas, nem as quatro semanas, nem o 1%. É a frase de que a maior parte do esforço foi para as especificações. Ela descreve uma mudança de onde o trabalho difícil mora quando a geração fica barata. Escrever a prova deixou de ser o gargalo neste experimento; decidir o que vale a pena provar, e dizer isso de forma precisa o bastante para uma máquina checar, continua sendo trabalho humano, lento e caro.

Preciso repetir os limites do que li. Descrevo um anúncio, um paper e um repositório de 10 a 12 de novembro, sem ter reproduzido nada. Os números são da DeepMind, o 1% aparece no blog mas não o encontrei no paper, o blog tem uma divergência interna entre três e seis milhões de linhas, o custo não foi divulgado e a cobertura da imprensa que li não traz avaliação de especialistas independentes. O que foi provado é um conjunto específico de propriedades sobre um binário AArch64 de um harness de linha de comando, sob hipóteses explícitas. É muito, e é menos do que as manchetes disseram.

Para quem revisa PR todo dia, a lição que fica é mais modesta e mais imediata do que verificação formal. Da próxima vez que eu ler "passou no teste", quero conseguir perguntar qual propriedade o teste está afirmando e quem garante que ela não foi enfraquecida no mesmo PR. Não sei quanto tempo vai levar até provas como essas chegarem a código de produto comum. Sei que a pergunta sobre o que exatamente está sendo garantido já cabe em qualquer revisão hoje.

Fontes:

Newsletter

Receba os artigos mais relevantes da semana, sem quebrar seu ritmo de leitura

Um resumo semanal com os melhores posts sobre IA, engenharia de software e tecnologia, enviado no melhor momento para continuar a conversa depois da leitura.

Foto de Elton José

Escrito por

eltonjose

Engenheiro de software e estrategista de produtos digitais, focado em IA pragmática e em transformar experiências de trabalho remoto em aprendizados aplicáveis. Compartilho frameworks e decisões reais que uso em consultorias e projetos.

  • Principais temasVerificação Formal, Lean
  • Formato do conteúdoGuia prático + insights de carreira