← Últimos artigos
💻 computer science

Untrusted Authors, Trusted Answers: A Calculus of Fidelity-Graded Translations

Este artigo apresenta um cálculo mecanizado em Lean 4 e um sistema de plano duplo ("hurdy-gurdy") que permite que LLMs não confiáveis gerem traduções autocertificadas e com gradação de fidelidade entre linguagens de programação, garantindo que um grafo de confiança continuamente evoluindo e verificado por humanos convirja para questões de programas decidíveis com segurança cada vez crescente.

Autores originais: Christoph Kirsch

Publicado 2026-07-20
📖 7 min de leitura🧠 Leitura aprofundada

Autores originais: Christoph Kirsch

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

O Dilema do Detetive: Quando Você Não Pode Confiar no Mensageiro

Imagine que você está tentando resolver um mistério sobre uma máquina complexa, como o motor de um carro ou o comportamento de um personagem de videogame. Você tem uma pergunta: "Este carro vai bater se eu acelerar a 50 mph?" Para responder a isso, você não pode apenas olhar para o carro; você precisa traduzir sua mecânica bagunçada do mundo real para uma linguagem que um resolvedor de computador superinteligente entenda, como uma equação matemática. Mas aqui está o problema: a pessoa que traduz o carro para a matemática pode cometer um erro. Talvez ela tenha esquecido uma engrenagem, ou talvez tenha entendido errado como os freios funcionam. Se o tradutor estiver errado, o resolvedor matemático lhe dará uma resposta perfeita para a pergunta errada.

No mundo da ciência da computação, este é o problema da "tradução". Frequentemente temos que mover um programa de uma linguagem (como C ou Python) para outra (como um quebra-cabeça lógico para um resolvedor) para verificar se ele é seguro. Tradicionalmente, os cientistas tentavam resolver isso provando que o tradutor era perfeito de uma vez por todas, como certificar que uma ponte é segura antes que alguém dirija sobre ela. Mas isso é incrivelmente difícil, especialmente quando os tradutores são complexos ou até mesmo escritos por inteligência artificial. Este artigo faz uma pergunta diferente: E se pararmos de tentar provar que o tradutor é perfeito e, em vez disso, construirmos um sistema que detecte os erros do tradutor enquanto ele está trabalhando? É a diferença entre confiar em um único guia para liderá-lo através de uma floresta e ter uma equipe de guias que verificam os mapas uns dos outros, com uma regra de que, se eles discordarem, você para e descobre quem está errado.

A Máquina "Hurdy-Gurdy": Uma Fábrica de Respostas Confiáveis

Este artigo apresenta um sistema chamado hurdy-gurdy (nomeado em homenagem a um instrumento musical que gera melodas, mas aqui ele gera respostas), os autores, liderados por Christoph Kirsch, propõem uma nova maneira de lidar com programas de computador: trate-os como um jogo de "telefone sem fio" onde cada etapa é verificada e cada resposta vem com um recibo.

A ideia central é simples, mas poderosa: Não confie no tradutor; confie no processo.

Imagine que você tem uma pergunta sobre um programa escrito em C. Em vez de apenas enviá-lo para um tradutor, o sistema o envia por dois caminhos diferentes.

  1. A Tradução: O programa é traduzido para uma linguagem lógica mais simples (como transformar um romance em uma equação matemática).
  2. A Dupla Verificação: O sistema executa o programa original e a versão traduzida lado a lado. Ele verifica se eles se comportam da mesma forma. Se sim, ótimo! Se não, o sistema aponta exatamente para o passo onde eles divergiram, como um árbitro soprando o apito no momento exato em que um jogador cometeu uma falta.
  3. O Truque da "Testemunha": Se o resolvedor disser: "Sim, um acidente é possível", o sistema não aceita apenas a palavra do resolvedor. Ele pega a "prova" (as condições específicas que causam o acidente) e a executa de trás para frente através da tradução. Ele alimenta essas condições no programa original. Se o programa original realmente sofrer o acidente, então a resposta é 100% real. O sistema "reproduziu" a cena do crime.

O sistema possui dois planos distintos, como uma fábrica e uma vitrine:

  • O Plano de Uso (A Vitrine): É onde as respostas acontecem. Aqui, uma IA (ou um humano) faz perguntas. O sistema não apenas adivinha; ele escolhe uma rota, verifica a tradução e, se a resposta for "Sim, é possível", ele executa a reprodução para provar. Se a resposta for "Não, é impossível", o sistema conta com uma pilha de verificações: múltiplos tradutores, múltiplos resolvedores e até certificados matematicamente verificados para ter certeza.
  • O Plano de Evolução (A Fábrica): É onde o sistema cresce. Se o sistema não consegue responder a uma pergunta, ele não desiste simplesmente; ele escreve por que falhou (ex: "Não temos um tradutor para este tipo específico de loop"). Ele então usa uma IA para construir um novo tradutor para preencher essa lacuna. Uma vez construído, o novo tradutor é testado contra os antigos. Se passar, ele é adicionado ao registro. Se falhar, ele é corrigido. Esse ciclo roda indefinidamente, tornando o sistema mais inteligente e confiável ao longo do tempo, mas crucialmente, o processo de crescimento nunca responde perguntas por si só. Ele apenas constrói as ferramentas para responder.

A Reviravolta dos "Autores Não Confiáveis"

A parte mais surpreendente do artigo é que os próprios tradutores foram construídos por agentes de IA não confiáveis. Os autores não codificaram os tradutores manualmente; eles pediram a modelos de IA que os escrevessem baseados em uma descrição de uma página. Normalmente, isso seria um desastre. Mas, como o sistema verifica cada etapa, os erros da IA foram detectados imediatamente.

Por exemplo, em um teste, um tradutor de IA omitiu uma instrução específica, fazendo com que ele se comportasse de forma diferente do programa original. A "verificação quadrada" do sistema (a comparação lado a lado) detectou o erro instantaneamente, apontando a linha exata e a variável exata que estava errada. O sistema então corrigiu o tradutor. O artigo mostra que, mesmo com autores de IA que podem estar errados, a arquitetura do sistema garante que as respostas finais sejam confiáveis.

O Que o Sistema Encontrou (e o Que Não Encontrou)

Os autores rodaram este sistema em um recorte de seu trabalho de julho de 2026. Aqui está o que eles mediram:

  • Cobertura: Eles traduziram com sucesso programas de 13 linguagens diferentes (incluindo C, Python e até redes de reações químicas) para resolvedores lógicos. Para a linguagem de processador RISC-V, eles cobriram 96 de 96 tipos específicos de instruções, o que significa que o sistema pôde lidar com cada instrução desse conjunto sem perder o rastro.
  • Concordância: Quando enviaram a mesma pergunta por dois caminhos de tradução diferentes (um baseado em um manual, outro em um modelo formal), as respostas concordaram 100% das vezes nos casos de teste.
  • Defeitos Detectados: O sistema detectou 24 defeitos específicos em seus próprios tradutores e ferramentas. Alguns eram erros de digitação simples, outros eram erros de lógica onde a IA entendeu errado como uma instrução de computador funcionava. Crucialmente, o sistema encontrou esses erros sem que um humano olhasse para o código.
  • O "Ponto Cego": O sistema também encontrou um limite. Se dois tradutores diferentes cometessem o mesmo erro exato (porque ambos entenderam mal a mesma regra), o sistema não conseguiria detectá-lo. Isso é chamado de "falha de modo comum". O artigo admite que este é um risco, mas o sistema é projetado para minimizar isso usando fontes diversas para as traduções.
  • Jogadores LLM: Eles testaram se uma IA poderia usar o sistema para responder perguntas. Em um experimento, uma IA sem ferramentas acertou 7 de 8 perguntas, mas chutou na difícil. A IA com o sistema acertou 8 de 8, e cada resposta veio acompanhada de uma prova verificada por máquina.

A Conclusão

Este artigo não afirma ter resolvido todos os problemas de segurança de computação. Não diz que os tradutores de IA são agora perfeitos. Em vez disso, prova que você pode construir um sistema confiável a partir de partes não confiáveis.

Ao tratar cada tradução como um erro potencial e construir uma "catraca" que só permite que as melhorias se consolidem, o sistema cria uma escada de confiança. Se a pergunta for "Isso pode acontecer?", o sistema pode reproduzir o evento para provar. Se a resposta for "Não, isso não pode acontecer", o sistema utiliza uma cadeia de verificações independentes e certificados matematicamente verificados para ter certeza.

Os autores concluem que esta abordagem — usando um grafo de rotas, verificando cada etapa e reproduzindo a evidência — é uma maneira viável de lidar com a complexidade do software moderno, mesmo quando as pessoas (ou IAs) que constroem as ferramentas são falíveis. É uma mudança de "confiar no autor" para "confiar na arquitetura".

Afogado em artigos na sua área?

Receba digests diários dos artigos mais recentes que correspondam às suas palavras-chave de pesquisa — com resumos técnicos, no seu idioma.

Experimentar Digest →