🔢 mathematics

GoldbachGPU: An Open Source GPU-Accelerated Framework for Verification of Goldbach's Conjecture

O artigo apresenta o GoldbachGPU, um framework de código aberto que supera as limitações de memória anteriores ao utilizar uma representação compacta de primos e um design de peneira segmentada para verificar exaustivamente a conjectura de Goldbach até 10^12 em uma única GPU de consumo, garantindo completude matemática e escalabilidade para múltiplos GPUs.

Autores originais: Isaac Llorente-Saguer

Publicado 2026-03-04

📖 5 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Isaac Llorente-Saguer

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

Imagine que você tem um quebra-cabeça matemático antigo e misterioso chamado Conjectura de Goldbach. A regra é simples: pegue qualquer número par grande (como 4, 10, 100, 1 bilhão) e tente escrevê-lo como a soma de dois números primos (números que só podem ser divididos por 1 e por eles mesmos, como 2, 3, 5, 7, 11...).

A matemática diz que isso é sempre possível, mas ninguém conseguiu provar isso para todos os números até hoje. Então, os cientistas usam computadores para testar bilhões e trilhões de números, procurando por um único caso onde a regra falhe. Se encontrarem um, a teoria cai. Se não encontrarem, a confiança aumenta.

O artigo que você leu apresenta uma ferramenta chamada GoldbachGPU. Vamos explicar como ela funciona usando analogias do dia a dia.

1. O Problema: A "Geladeira" Pequena

Antes dessa nova ferramenta, os computadores tentavam guardar uma "lista mestra" de todos os números primos na memória do processador gráfico (a placa de vídeo, ou GPU).

Pense na memória da placa de vídeo como uma geladeira.

Para verificar números até 10 bilhões, a lista de primos cabia na geladeira.
Mas, quando tentavam ir além (para 100 bilhões ou 1 trilhão), a lista de primos ficava tão grande que não cabia mais na geladeira. Era como tentar colocar um elefante inteiro dentro de uma geladeira de cozinha. O computador travava porque a memória acabava. Isso era chamado de "teto de memória".

2. A Solução: A "Caixa de Ferramentas" Inteligente

O pesquisador Isaac Llorente-Saguer criou o GoldbachGPU para resolver esse problema de duas formas criativas:

A. Compactando os Dados (A "Mala de Viagem")

Antes, os números primos eram guardados como se cada um ocupasse um espaço enorme (como um casaco de inverno). O novo método usa uma técnica de "bit-packing" (empacotamento em bits).

Analogia: Imagine que você precisa levar 16 casacos de inverno para uma viagem. Em vez de levar 16 malas grandes, você usa uma técnica especial para dobrar todos eles até ficarem do tamanho de apenas uma mala pequena.
Resultado: Isso reduziu o espaço necessário em 16 vezes! De repente, a "geladeira" da placa de vídeo ficou grande o suficiente para guardar listas muito maiores.

B. O Método de "Vasculhar em Blocos" (A "Caixa de Ferramentas")

Mesmo com a mala menor, 1 trilhão de números ainda é muita coisa para caber de uma vez. Então, o GoldbachGPU mudou a estratégia de como busca a resposta.

O jeito antigo: Tentar adivinhar dois números para somar 1 trilhão, verificando um por um. Era como tentar achar uma agulha em um palheiro gigante olhando para o palheiro inteiro de uma vez.
O novo jeito (GoldbachGPU): Em vez de olhar o palheiro todo, eles dividem o palheiro em pequenas caixas.
1. Eles pegam uma pequena caixa (um pedaço da lista de números).
2. Verificam se os números ali funcionam.
3. Jogam a caixa fora e pegam a próxima.
4. A "geladeira" nunca precisa guardar o palheiro inteiro, apenas uma caixa de cada vez.

Isso significa que, não importa se você quer verificar até 10 bilhões ou 10 trilhões, a placa de vídeo só precisa de um espaço fixo e pequeno (o tamanho de uma caixa). O "teto" da memória desapareceu!

3. O Resultado: Um Computador Comum Faz o Trabalho de um Supercomputador

Com essa técnica, o autor conseguiu rodar o teste em uma placa de vídeo de computador comum (uma NVIDIA RTX 3070, que você pode comprar em qualquer loja de eletrônicos), que tem apenas 8 GB de memória.

O feito: Eles verificaram todos os números pares até 1 trilhão (10^12).
O tempo: Feito em menos de 2 horas.
O resultado: Nenhum erro foi encontrado. A conjectura continua válida!

Além disso, eles criaram um "plano B" (um verificador no processador principal) que garante que, se a placa de vídeo falhar ou tiver dúvida, o computador principal faz a verificação lenta, mas 100% correta, para garantir que nada foi esquecido.

4. Números Gigantes (Além do 64 bits)

O projeto também tem uma ferramenta para verificar números astronomicamente grandes (com milhares de dígitos, muito maiores que o número de átomos no universo).

Analogia: Se os números comuns são como verificar se uma chave abre uma porta, esses números gigantes são como tentar abrir um cofre nuclear.
Eles conseguiram verificar números com 10.000 dígitos. É um trabalho pesado, mas a ferramenta funciona, provando que a conjectura vale mesmo para números que a gente nem consegue imaginar.

Resumo Final

O GoldbachGPU é como um "truque de mágica" computacional. Ele pegou um problema que parecia exigir um supercomputador gigante e mostrou que, com uma organização inteligente (dividir em caixas e compactar dados), um computador de casa consegue fazer o mesmo trabalho.

Eles provaram que a Conjectura de Goldbach é verdadeira para todos os números até 1 trilhão, usando apenas hardware que qualquer entusiasta pode ter, e deixaram o código aberto para que qualquer pessoa possa verificar e melhorar.

Resumo Técnico: GoldbachGPU

1. O Problema

A Conjectura de Goldbach afirma que todo número inteiro par maior que 2 pode ser expresso como a soma de dois números primos. Embora não tenha sido provada matematicamente, sua verificação computacional é crucial.

Limitação Atual: Abordagens anteriores baseadas em GPU enfrentaram um "teto de memória" (VRAM) rígido próximo a $10^{11}$ . A alocação monolítica de tabelas de primos na memória da GPU tornava a verificação exaustiva além desse limite inviável em hardware de consumo.
Desafio: Como realizar uma verificação exaustiva de $N$ muito grandes (ex: $10^{12}$ ) em uma única GPU comercial sem depender de infraestrutura distribuída massiva, superando as restrições de memória e divergência de threads.

2. Metodologia

O framework GoldbachGPU introduz uma arquitetura inovadora composta por cinco ferramentas complementares, sendo a principal a verificação segmentada.

Representação Compacta (Bitset Denso):
- Em vez de armazenar primos como arrays de bytes (1 byte por número), o sistema utiliza um bitset denso.
- Como apenas números ímpares (exceto 2) podem ser primos, o índice do bit é calculado para números ímpares.
- Resultado: Redução de 16× na pegada de memória. Uma tabela para $10^{11}$ requer apenas ~6 GB de VRAM (dentro do limite de uma RTX 3070 de 8 GB), contra ~95 GB em formato de byte.
Arquitetura de Peneira Dupla Segmentada (Segmented Double-Sieve):
- Inspirada na estratégia de inversão de loop de Oliveira e Silva, o framework inverte a verificação: em vez de iterar sobre números pares $n$ e buscar $p$ , ele itera sobre primos candidatos $p$ e marca os pares $n$ onde $q = n - p$ é primo.
- Segmentação: A verificação é dividida em segmentos de tamanho fixo (ex: $10^7$ pares). Apenas o bitset do segmento atual e uma pequena tabela de primos pequenos são mantidos na VRAM.
- Oráculo de Primacidade de 3 Níveis: Para determinar se $q = n - p$ $q = n - p$ é primo, o sistema usa uma cadeia de prioridade:
  1. Lookup em Bitset Pequeno: Se $q \le P_{SMALL}$ (primos permanentemente residentes na GPU).
  2. Lookup em Bitset do Segmento: Se $q$ está no segmento atual na VRAM.
  3. Teste de Miller-Rabin: Se $q$ está na região de transição ( $P_{SMALL} < q < A$ ), usa-se um teste determinístico de 64 bits.
- Isso elimina a necessidade de uma tabela monolítica de primos na VRAM, mantendo o uso de memória em O(1) em relação a $N$ .
Fallback Rigoroso (CPU):
- Se a fase rápida da GPU falhar em encontrar uma partição para algum $n$ , um fallback exaustivo na CPU (sem limite superior para $p$ ) garante a completude matemática. Em todos os testes, este fallback nunca foi acionado.
Verificadores de Precisão Arbitrária:
- Single Check: Para números de 64 bits individuais, usa teste de Miller-Rabin na GPU.
- Big Check: Usa a biblioteca GMP (GNU Multiple Precision) para verificar números gigantes (até $10^{10000}$ ). Implementa uma estratégia de busca em lote sincronizada com barreiras OpenMP para evitar desequilíbrio de carga (thread runaway).

3. Principais Contribuições

Eliminação do Teto de VRAM: A arquitetura segmentada removeu a barreira de memória, permitindo verificação exaustiva até $10^{12}$ em uma única GPU de consumo (NVIDIA RTX 3070).
Otimização de Memória: O bitset denso permite tabelas de primos na GPU até $10^{11}$ , uma redução de 16× sobre métodos anteriores.
Complexidade Otimizada: O design alcança tempo de parede O(N) e uso de memória O(1) (fixo em ~14 MB por segmento), independentemente do tamanho total de $N$ .
Implementação Open Source: Código totalmente documentado, reproduzível e escalável para múltiplas GPUs (testado em 8x H100).

4. Resultados

Verificação Exaustiva: O sistema verificou todos os números pares até $10^{12}$ em uma RTX 3070 em aproximadamente 41 minutos.
Eficiência de Memória: O uso de VRAM permaneceu constante em ~14 MB por segmento, permitindo a escalabilidade.
Taxa de Sucesso: 100% dos segmentos foram resolvidos na "fase rápida" (GPU). O fallback da CPU nunca foi necessário, confirmando empiricamente que o menor primo de Goldbach $p_{min}(n) \le 2 \times 10^6$ para todo $n \le 10^{12}$ .
Precisão Arbitrária: O verificador big check validou números de até $10^{10000}$ (10.001 dígitos) em 182 segundos (20 threads), utilizando a estratégia de lotes sincronizados.
Escalabilidade:
- Em hardware de consumo (RTX 3090), a eficiência de paralelismo manteve-se acima de 91% com 4 GPUs.
- Em data centers (H100), o tempo de execução para $N=10^{10}$ foi similar ao de GPUs de consumo, indicando que o gargalo atual é a construção da peneira na CPU (host), não a GPU.

5. Significado e Conclusão

O trabalho demonstra que as limitações de memória relatadas em estudos anteriores de GPU eram arquiteturais (devido ao armazenamento monolítico) e não fundamentais.

Avanço: O GoldbachGPU aumenta em uma ordem de magnitude o limite de verificação exaustiva em uma única GPU (de $10^{11}$ para $10^{12}$ ) sem infraestrutura distribuída.
Validação Empírica: Reforça a "conjectura do cometa de Goldbach", mostrando que as partições usando primos pequenos são abundantes.
Futuro: O próximo passo identificado é substituir as verificações individuais por operações de "bulk-marking" (marcação em massa) via bitwise na GPU, o que poderia reduzir a complexidade para $O(N \log \log N)$ e permitir atingir $10^{15}$ em uma única GPU.

O código-fonte está disponível publicamente, permitindo a reprodução dos resultados em hardware comercial e de alto desempenho.