GNFS on kenji.blog

【Análise Completa】Entendendo e Implementando o Mais Forte Algoritmo de Quebra de Criptografia 'GNFS' em C++

Sat, 05 Sep 2026 13:04:59 +0900

【Análise Completa】Entendendo e Implementando o Mais Forte Algoritmo de Quebra de Criptografia “GNFS” em C++

A criptografia RSA, que sustenta a internet moderna, baseia-se na crença matemática de que “é virtualmente impossível para os computadores atuais fatorar números compostos gigantescos”.

No entanto, a humanidade nunca desistiu. Atualmente, existe o mais forte e avançado algoritmo da humanidade para a fatoração de grandes números primos em computadores clássicos (não quânticos). É o “General Number Field Sieve (GNFS - Crivo Geral do Corpo de Números)”.

Neste artigo, publicaremos o código de implementação completo que modela estritamente a lógica de computação mais avançada do GNFS em C++ (usando os inteiros de multiprecisão boost::multiprecision da biblioteca Boost), e explicaremos minuciosamente as profundezas da “teoria algébrica dos números” por trás dele.

Por favor, aproveite os mistérios da matemática e a força bruta da ciência da computação que os domina, juntamente com o código-fonte.

1. Framework de Lógica GNFS Avançado (Código Fonte Completo)

Primeiro, apresentaremos o quadro geral da implementação C++ do GNFS que explicaremos desta vez. Embora o GNFS real (como o CADO-NFS) seja um enorme sistema distribuído que abrange centenas de milhares de linhas, este código extrai e modela as “5 pipelines (fases) essenciais” que compõem o GNFS no design de classes, na configuração mínima, sem perder seu significado matemático.

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228


#include <iostream>
#include <vector>
#include <cmath>
#include <map>
#include <set>
#include <chrono>
#include <boost/multiprecision/cpp_int.hpp>

// Usando inteiros de multiprecisão do Boost.Multiprecision
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] Framework Lógico Avançado do General Number Field Sieve (Crivo Geral do Corpo de Números)
//
// Este código modela estritamente os 5 pipelines avançados do GNFS usados
// no CADO-NFS etc., como o design de classes C++ (Boost).
// ============================================================================

struct Relation {
 int64_t a;
 int64_t b;
 std::vector<uint32_t> rational_primes;
 std::vector<uint32_t> algebraic_primes;
};

// ============================================================================
// Fase 1: Polynomial Selection (Seleção Polinomial - Algoritmo de KleinJung)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // Polinômio do lado algébrico f(x)
 std::vector<cpp_int> g; // Polinômio do lado racional g(x) = x - m
 cpp_int m;

 PolynomialSelector(int d) : degree(d) {}

 // Geração do polinômio inicial baseado na expansão base-m (Na realidade, usa a redução de base reticulada LLL, que é mais avançada)
 void select(const cpp_int& N) {
 std::cout << "[Fase 1] Seleção Polinomial (Grau " << degree << ") iniciando..." << std::endl;
 // Expansão base-m simples (grau d)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // Aproximação simples de m (Aproximação sem usar as funções do Boost)
 cpp_int low = 1, high = N;
 while (low <= high) {
 cpp_int mid = low + (high - low) / 2;
 cpp_int p = 1;
 for(int i=0; i<degree; ++i) p *= mid;
 if (p <= N) { m = mid; low = mid + 1; }
 else { high = mid - 1; }
 }

 f.resize(degree + 1);
 cpp_int temp = N;
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }

 g = {-m, 1}; // g(x) = x - m

 std::cout << " -> m = " << m << std::endl;
 std::cout << " -> f(x) = ";
 for(int i = degree; i >= 0; --i) {
 std::cout << f[i] << "x^" << i << (i > 0 ? " + " : "");
 }
 std::cout << "\n[Fase 1] Concluída." << std::endl;
 }
};

// ============================================================================
// Fase 2: Lattice Sieving (Crivo de Reticulado)
// ============================================================================
// Nos últimos anos, em vez de Line Sieve (Crivo de Linha), o Special-q Lattice Sieving (Crivo de Reticulado q Especial)
// de Franke-Kleinjung e outros é o padrão de fato.
class LatticeSieve {
 uint32_t rational_bound;
 uint32_t algebraic_bound;
 std::vector<uint32_t> rational_fb;
 std::vector<uint32_t> algebraic_fb;

public:
 LatticeSieve(uint32_t rb, uint32_t ab) : rational_bound(rb), algebraic_bound(ab) {}

 void generate_factor_bases() {
 std::cout << "[Fase 2] Gerando Bases de Fator (Limite Racional: " << rational_bound << ", Limite Algébrico: " << algebraic_bound << ")" << std::endl;
 // (Omitido) Na realidade, ele gera números primos e restringe usando o símbolo de Legendre etc.
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Fase 2] Special-q Lattice Sieving ativo..." << std::endl;
 std::vector<Relation> relations;
 // Implementação simulada: O crivo de reticulado real varre centenas de GB de espaço de memória em unidades de bloco.
 // Mapeia o par (a, b) para a grade para cada primo especial q (a = i*q + j*...) e
 // executa um sieve (crivo) que maximiza a eficiência do cache ao limite.

 // Adicionando uma relação simulada para fins de demonstração
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[Fase 2] Encontradas " << relations.size() << " relações." << std::endl;
 return relations;
 }
};

// ============================================================================
// Fase 3: Filtering (Expurgo de Singularidades e Fusão de Cliques)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Fase 3] Filtrando Relações..." << std::endl;
 // 1. Singleton removal (Remoção de relações com números primos que aparecem apenas uma vez)
 // 2. Clique merging (Fusão de relações para tornar uma matriz esparsa em uma matriz densa)
 // Na verdade, comprime matrizes de centenas de milhões de linhas em alguns milhões usando algoritmos como Union-Find.
 std::cout << "[Fase 3] Tamanho da matriz reduzido idealmente." << std::endl;
 }
};

// ============================================================================
// Fase 4: Linear Algebra over GF(2) (Método Block Wiedemann)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // Em ambientes de supercomputadores recentes, o Método Block Wiedemann (Implementação de Coppersmith)
 // é usado como a tecnologia mais avançada porque é mais adequado para computação distribuída
 // do que o Método Block Lanczos.
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Fase 4] Algoritmo de Block Wiedemann sobre GF(2) iniciando..." << std::endl;
 // Repete a operação de produto da matriz esparsa e vetor,
 // e encontra vários vetores de solução (kernel) em que M * x = 0 mod 2.

 std::vector<std::vector<int>> dependencies; // Lista de dependências
 // Dados simulados
 dependencies.push_back({0});

 std::cout << "[Fase 4] Encontradas " << dependencies.size() << " dependências lineares (quadrados perfeitos)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Fase 5: Algebraic Square Root (Raiz Quadrada Algébrica)
// ============================================================================
class AlgebraicSquareRoot {
public:
 void compute_and_factor(const std::vector<Relation>& relations, const std::vector<int>& dep, const cpp_int& N) {
 std::cout << "[Fase 5] Computação da Raiz Quadrada Algébrica..." << std::endl;

 // 1. Cálculo da raiz quadrada V no lado racional (Operação de inteiro simples)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. Cálculo da raiz quadrada gamma no lado algébrico (Método de Montgomery, etc.)
 // Obtém o elemento gamma do enorme corpo algébrico O_K e o mapeia para o mundo real com o homomorfismo phi
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // Pressupõe que sequências de Caracteres Quadráticos (Quadratic Characters)
 // foram adicionadas nas Fases 2 e 4 para evitar a obstrução (Obstruction) do grupo de classes de ideais e o grupo de unidades.

 std::cout << " -> Mapa de homomorfismo phi aplicado." << std::endl;
 std::cout << "[Fase 5] Calculando GCD(V - Y, N)..." << std::endl;

 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)

 if (factor > 1 && factor < N) {
 std::cout << "\n================================================================" << std::endl;
 std::cout << "[SUCESSO] Fator não trivial encontrado: " << factor << std::endl;
 std::cout << " Outro fator: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[FALHA] Solução trivial. Tentando próxima dependência..." << std::endl;
 }
 }
};

// ============================================================================
// Main Execution Pipeline (Pipeline de Execução Principal)
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] Motor do General Number Field Sieve (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // O grande número composto N que queremos fatorar, como RSA-270
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // Grau do polinômio (Normalmente, de 5º a 6º grau é selecionado para números com mais de 130 dígitos)
 int degree = 6;

 // Inicializando pipelines
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // Na realidade, os limites são dezenas de milhões a centenas de milhões
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

 auto start_time = std::chrono::high_resolution_clock::now();

 // 1. Seleção Polinomial
 poly_select.select(N);

 // 2. Processamento do Sieve (Crivo)
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. Filtragem (Compressão de Matriz)
 filter.reduce_matrix(relations);

 // 4. Álgebra Linear (Busca de espaço nulo (Nullspace) em GF(2))
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. Cálculo da Raiz Quadrada Algébrica e GCD
 for (const auto& dep : dependencies) {
 sqrt_step.compute_and_factor(relations, dep, N);
 }

 auto end_time = std::chrono::high_resolution_clock::now();
 std::chrono::duration<double> elapsed = end_time - start_time;
 std::cout << "\n[Sistema] Pipeline GNFS Avançado concluído em " << elapsed.count() << " segundos." << std::endl;

 return 0;
}

Então, como este código quebra os muros da criptografia? Explicaremos detalhadamente a matemática avançada e os algoritmos precisos para cada uma das 5 fases.

2. Objetivo Final do GNFS: $X^2 \equiv Y^2 \pmod N$

O objetivo da maioria dos algoritmos modernos de fatoração de grandes números, não apenas o GNFS, é encontrar um par não trivial $(X, Y)$ que satisfaça a seguinte congruência:

$$X^2 \equiv Y^2 \pmod N$$

Esta fórmula significa que “o resto de $X^2$ e $Y^2$ quando divididos por $N$ é o mesmo”. Se reescrevermos isso, obtemos: $X^2 - Y^2 \equiv 0 \pmod N$ Em outras palavras, $(X-Y)(X+Y)$ é um múltiplo de $N$.

Se $X \not\equiv \pm Y \pmod N$ (uma solução não trivial), então haverá um “divisor comum maior que 1 e menor que $N$” entre $(X-Y)$ e $N$. Aqui, usando o algoritmo de Euclides para calcular $\gcd(X-Y, N)$ , os fatores primos de $N$ podem ser encontrados muito facilmente.

No entanto, encontrar esses $X$ e $Y$ é como procurar uma agulha em um palheiro. Portanto, o GNFS tem uma abordagem genial: criar dois mundos - “o mundo dos inteiros reais” e “o mundo dos corpos algébricos dos polinômios” - e distribuir a computação.

3. Fase 1: Seleção Polinomial (Polynomial Selection)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // Cálculo de m = N^(1/d) e expansão base-m
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

O primeiro passo do GNFS é criar os “polinômios mágicos” para fazer a ponte entre os dois mundos. Para um número muito grande $N$, escolhemos um número inteiro $m$. Normalmente o escolhemos de modo que $m \approx N^{1/d}$ (no código, assumimos um polinômio de grau $d=6$).

Em seguida, o $N$ é expandido na base $m$, e esses coeficientes são usados para construir um polinômio $f(x)$.

$$N = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$$ $$f(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_1 x + c_0$$

Este polinômio $f(x)$ tem uma propriedade muito importante: “Se substituirmos $x$ por $m$, o resultado será exatamente $N$ ($f(m) = N$)” . Em outras palavras, $f(m) \equiv 0 \pmod N$. O polinômio do lado racional é definido como $g(x) = x - m$.

Com isso, “o mundo do corpo algébrico $\mathbb{Z}[\alpha]$” governado pela raiz $\alpha$ de $f(x)=0$, e “o mundo dos números racionais (inteiros) $\mathbb{Z}$” estão fortemente ligados pelo “mapa de homomorfismo de anel” $x \to m$.

No CADO-NFS mais avançado, usa-se o algoritmo de KleinJung ou o algoritmo de redução de base de reticulado LLL para passar meses procurando o “polinômio mais conveniente $f(x)$” cujos coeficientes não são extremamente grandes e em que os números primos são mais propensos a aparecer (lisos) nas etapas subsequentes.

4. Fase 2: Crivo de Reticulado $q$ Especial (Special-q Lattice Sieving)

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // Mapeia os pares (a, b) para reticulados baseados em cada número primo especial q
 // e executa o sieve (crivo) de forma muito eficiente usando a memória cache.
 // ...
 }
};

Com os dois mundos prontos, o próximo passo é procurar “números lisos” (números compostos apenas por números primos pequenos) em ambos os mundos. Geramos inúmeros pares de inteiros $(a, b)$ e calculamos os dois valores a seguir:

Valor racional: $a - bm$
Norma algébrica: $b^d f(a/b)$

O objetivo do GNFS é coletar de dezenas a centenas de milhões desses “pares (Relação) em que os valores dos lados racional e algébrico podem ser completamente decompostos em fatores primos pequenos” .

No GNFS inicial, era usado o “Line Sieve” (Crivo de Linha), no qual $(a, b)$ são alinhados em um plano $xy$ e sequencialmente divididos por números primos da borda. Mas esse método apresentava a fraqueza de ser muito lento por acessar memórias espalhadas causando muitos erros de cache.

Por isso, na vanguarda, utiliza-se a técnica “Crivo de Reticulado $q$ Especial (Special-q Lattice Sieve)”. Isso fixa um número primo consideravelmente grande $q$ e visa calcular apenas “os pares $(a, b)$ nos quais o valor algébrico é sempre divisível por $q$”. Os $(a, b)$ que satisfazem essa condição formam uma “Lattice” (Reticulado) no plano. Então, a largura do salto dos endereços de memória a calcular torna-se constante, o que se adapta perfeitamente aos caches L1/L2 da CPU. Graças a essa introdução do Crivo de Reticulado, a velocidade de computação do GNFS aumentou drasticamente.

5. Fase 3: Filtragem (Filtering)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Singleton removal (Remoção de relações com números primos que aparecem apenas uma vez)
 // 2. Clique merging (Fusão de relações para tornar uma matriz esparsa em uma matriz densa)
 }
};

Na Fase 2, as relações coletadas ao longo de meses por computadores em todo o mundo somam centenas de milhões. No entanto, se inserirmos isso como está no próximo passo de “resolução do sistema de equações” (cálculo de matriz), a memória dos supercomputadores falhará.

Portanto, ocorre um processo de supercompressão de matriz chamado Filtering (Filtragem) .

Singleton removal (Expurgo de singularidades): Suponha que um número primo enorme $p$ apareça “apenas uma vez” entre as centenas de milhões de relações. Nosso objetivo é “tornar o expoente de todos os números primos um número par (múltiplo de 2)”; os números primos que aparecem apenas uma vez nunca podem ser tornados pares. Portanto, a relação que inclui aquele número primo é imediatamente removida (expurgada) como “lixo sem utilidade”. Quando isso acontece em cadeia, os dados que antes eram de centenas de milhões de linhas são sistematicamente reduzidos.
Clique merging (Fusão de cliques): Ao cruzar e somar relações que compartilham um número primo em comum, diminuímos o número de linhas e, simultaneamente, transformamos a matriz esparsa (cheia de zeros) numa matriz mais densa (método semelhante à busca de cliques na teoria dos grafos).

Com essas otimizações, a gigantesca matriz esparsa é comprimida a um tamanho possível de calcular.

6. Fase 4: Álgebra Linear em GF(2) (Método Block Wiedemann)

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // Repete a operação de produto da matriz esparsa e vetor,
 // e encontra vários vetores de solução (kernel) em que M * x = 0 mod 2.
 }
};

Finalmente, a essência do quebra-cabeça. Multiplicamos as relações recolhidas buscando as “combinações que tornam o expoente de todos os fatores primos par” .

Em termos matemáticos, isso equivale a encontrar um vetor de solução $x$ (espaço nulo / kernel) onde, utilizando uma matriz gigante $M$ com elementos sendo o expoente de cada número primo no “par ou ímpar (ou seja, 0 ou 1)” e um vetor $x$ que diz quais relações usar, temos: $M \cdot x \equiv 0 \pmod 2$

É necessário resolver equações simultâneas de uma matriz de milhões de linhas por milhões de colunas. O uso tradicional do método de eliminação de Gauss levaria $O(N^3)$ em tempo de cálculo e não acabaria antes do fim do universo.

Por esse motivo, as implementações de ponta utilizam o “Método de Block Wiedemann”. Esse método aproveita que a matriz $M$ é “extremamente esparsa (quase totalmente zeros)” para obter a solução multiplicando iterativamente matrizes por vetores. É um tipo de método do subespaço de Krylov. Diferente do antigo Block Lanczos, o método Block Wiedemann pode particionar totalmente o processo computacional entre vários clusters, tornando seu uso extremamente valioso em clusters modernos e em sistemas paralelos de computação distribuída (cloud e supercomputadores).

7. Fase 5: Raiz Quadrada Algébrica (Algebraic Square Root) e o Colapso Criptográfico

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. Cálculo da raiz quadrada V no lado racional
 cpp_int V = 1;

 // 2. Cálculo da raiz quadrada gamma no lado algébrico
 cpp_int Y = 1;

 // ...
 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)
 }
};

Pelo cálculo matricial na Fase 4, adquirimos o “conjunto de relações $S$ cujos expoentes de todos os fatores primos formam um expoente par quando multiplicados juntos”. Isto possibilita construir o “quadrado perfeito” em ambos os mundos: o lado racional e o lado algébrico.

No lado racional, o cálculo é uma simples multiplicação de números inteiros, por isso é simples calcular sua raiz quadrada $V$.

$$V^2 = \prod_{S} (a - bm)$$

Porém, o real pesadelo encontra-se no “lado algébrico”. No mundo do corpo algébrico $\mathbb{Z}[\alpha]$, dado que a unicidade da fatoração em primos não é mantida, realizávamos cálculos usando ideais. A garantia dada pelo cálculo matricial era “apenas que seria o quadrado de um ideal, e não garantia que seria o quadrado de um elemento ($\gamma^2$)”.

Deste modo, surge uma imensa barreira provinda da teoria algébrica dos números, as chamadas “Obstrução do grupo de classes de ideais” e a “Obstrução do grupo das unidades”. No GNFS, usamos a mágica do “Caracter Quadrático (Quadratic Characters)” para quebrar essa parede. Inserimos sorrateiramente várias colunas de símbolos residuais quadráticos (símbolos de Legendre) na matriz da Fase 4 para uma dezena de números ideais primos, de forma que a chance de as obstruções sumirem aumente brutalmente, e que assim, garantam finalmente “o autêntico quadrado de um elemento $\gamma^2$”.

Em seguida, calcula-se o $\gamma$ (raiz quadrada algébrica) usando algoritmos complexos, como o método de Montgomery.

Por último, fazemos a raiz algébrica $\gamma$ sofrer um “warp” para o mundo verdadeiro usando o mapa de homomorfismo de anéis $\phi$ (substituindo $x$ por $m$) para encontrar $Y$. Quando colocamos o $V$ do lado racional para ser o $X$, a equação absoluta cobiçada está finalmente perfeita.

$$X^2 \equiv Y^2 \pmod N$$

O restante é somente resolver o $\gcd(X-Y, N)$. Em milissegundos o processo acaba e exibe o fator não trivial impresso na tela. Nesse instante, a criptografia impenetrável RSA é inteiramente derrubada.

Conclusão

O GNFS não é só uma técnica de programação. Trata-se de forçar as “profundezas da matemática pura” como álgebra abstrata, teoria dos anéis e os grupos de classe ideal através do poder colossal da “engenharia extrema”, como arquitetura de computadores distribuída em supercomputadores, além de otimizações de cache; um pilar glorioso da mente humana.

Por trás de transações por cartão de crédito ou simples chats do dia-a-dia, encontra-se esta astronômica barreira defensiva construída através do poderio e batalha da matemática.

Espero que compreendam que, na retaguarda dos fortes algoritmos criptográficos, existe um “romance dos computadores com a matemática” oculto neste simples framework em C++.

A Verdadeira Estrutura Matemática do Crivo Geral dos Corpos de Números (GNFS)

Sat, 05 Sep 2026 02:26:13 +0900

A Verdadeira Estrutura Matemática do Crivo Geral dos Corpos de Números (GNFS)

O objetivo final do GNFS é encontrar $X, Y$ tais que $X^2 \equiv Y^2 \pmod N$. Para alcançar isso, os matemáticos construíram uma ponte entre o “mundo dos inteiros reais” e o “mundo dos corpos algébricos” . Essa ponte é exatamente o “homomorfismo”.

Fase 1: Conectando os mundos com “Homomorfismo”

1. Seleção do polinômio e definição das raízes

Para um número composto gigante $N$, escolhemos um inteiro $m$ e um polinômio $f(x)$ tais que $f(m) \equiv 0 \pmod N$. (Exemplo: Expandimos $N$ na base $m$ e criamos $f(x)$ a partir de seus coeficientes. Neste momento, assumimos que $f(x)$ é irredutível sobre o corpo dos números racionais $\mathbb{Q}$ (não pode ser mais fatorado)).

Em seguida, definimos uma das “raízes complexas” da equação $f(x) = 0$ como $\alpha$. Naturalmente, $f(\alpha) = 0$. $\alpha$ não é um número inteiro, mas um número complexo envolvendo raízes e números imaginários (um número algébrico).

2. Construção de Anéis (Rings) e Homomorfismo

Aqui, preparamos dois “anéis” matemáticos (mundos onde adição e multiplicação são definidas).

Mundo A: $\mathbb{Z}[\alpha]$ (O anel dos inteiros algébricos contendo $\alpha$) Um mundo de números expressos na forma $a + b\alpha + c\alpha^2 + \dots$.
Mundo B: $\mathbb{Z}/N\mathbb{Z}$ (O anel dos restos módulo $N$) Um mundo de congruências composto apenas por inteiros de $0$ a $N-1$.

Aqui, definimos um mapeamento $\phi$ do Mundo A para o Mundo B da seguinte forma. $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

Este mapeamento $\phi$ é uma operação mágica que substitui exatamente a variável $\alpha$ do Mundo A pelo inteiro $m$ do Mundo B. Este $\phi$ possui uma propriedade extremamente poderosa chamada “Homomorfismo de Anéis (Ring Homomorphism)” . Homomorfismo é a propriedade de “teleportar para outro mundo sem destruir a estrutura da adição e multiplicação” . Em outras palavras, as seguintes equações são válidas:

$\phi(X \times Y) = \phi(X) \times \phi(Y)$
$\phi(X^2) = \phi(X)^2$

O que isso significa? Se pudermos criar o “quadrado ($\gamma^2$)” de algum elemento complexo $\gamma$ no “Mundo A (o mundo de $\alpha$)”, e teleportá-lo para o “Mundo B (mundo dos restos)” usando $\phi$, a forma quadrada $\phi(\gamma)^2$ é perfeitamente preservada .

Fase 2: O Colapso da Fatoração em Números Primos e o Nascimento dos “Ideais”

No Mundo A ($\mathbb{Z}[\alpha]$), queremos reunir muitos elementos adequados $(a - b\alpha)$ e multiplicá-los para criar um “quadrado perfeito (elemento quadrado)”. Normalmente, faríamos a “fatoração em números primos” de cada $(a - b\alpha)$ coletado e os combinaríamos de forma que os expoentes dos primos fossem todos pares (resolvendo com matrizes) para formar um quadrado.

No entanto, aqui, a parede desesperadora da álgebra se ergue. Em mundos de corpos algébricos como $\mathbb{Z}[\alpha]$, a “unicidade da fatoração em números primos (qualquer número pode ser expresso de forma única como o produto de primos)” ensinada no ensino médio colapsa .

(Exemplo: Em um certo mundo de corpo algébrico, $6 = 2 \times 3$, mas ao mesmo tempo $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$, e não sabemos mais quais são os verdadeiros primos)

Se a fatoração não for única, o quebra-cabeça de “contar o número de primos para torná-los pares” (o método do crivo) é, em princípio, impossível de executar.

A Salvação de Kummer e Dedekind: “Ideais”

O que salvou esse colapso foi o conceito de “Ideal (Ideal: número ideal)” criado pelos matemáticos do século 19. Pensando não no elemento em si, mas no “conjunto de múltiplos (ideal)” gerado por esse elemento, a fatoração em números primos tornou-se possível novamente.

No anel de inteiros de um corpo algébrico $\mathcal{O}_K$ (um anel mais completo contendo $\mathbb{Z}[\alpha]$), é provado que mesmo que um elemento não possa ser fatorado unicamente, “um ideal sempre pode ser fatorado unicamente como o produto de ‘Ideais Primos ($\mathfrak{p}$)’” .

Portanto, no GNFS, em vez de fatorar o próprio elemento $(a - b\alpha)$, fatoramos o ideal principal $\langle a - b\alpha \rangle$ gerado por ele em ideais primos .

Fase 3: A Norma (Norm) e os Dois Crivos (Sieves)

Então, como sabemos em quais ideais primos o ideal $\langle a - b\alpha \rangle$ é decomposto? Aqui usamos uma função chamada “Norma (Norm)” . A Norma é uma função que converte elementos complexos de corpos algébricos em “inteiros reais normais $\mathbb{Z}$”.

A norma do elemento $(a - b\alpha)$ é encontrada por um cálculo polinomial simples $b^d f(a/b)$ ($d$ é o grau de $f(x)$).

Por um teorema algébrico, sabemos que “se a norma de um certo ideal puder ser completamente fatorada em pequenos números primos (for suave), então o ideal original também pode ser completamente fatorado em pequenos ideais primos” .

Então, para um grande número de pares de inteiros $(a, b)$, o GNFS calcula os dois seguintes simultaneamente e coleta apenas os pares em que ambos se tornam “números suaves”:

Crivo Racional (Rational Sieve) : $a - bm$ (o valor no mundo real)
Crivo Algébrico (Algebraic Sieve) : $b^d f(a/b)$ (a norma no mundo dos corpos algébricos)

Coletando dezenas de milhões de pares $(a, b)$ em que ambos são suaves, resolvemos os dados de fatoração de ideais primos (quantos ideais primos estão incluídos) como uma matriz gigante (álgebra linear sobre GF(2)) para encontrar um conjunto $S$ de pares tal que “quando multiplicados, os expoentes de todos os ideais primos se tornem pares”.

Fase 4: Os Dois “Obstáculos” e o Grupo de Classes de Ideais

A partir do cálculo da matriz, descobrimos que multiplicar todos os ideais de $(a - b\alpha)$ pertencentes ao conjunto $S$ resulta no quadrado de um certo ideal $I$.

$$\prod_{S} \langle a - b\alpha \rangle = I^2$$

No entanto, ainda não acabou. A barreira matemática mais profunda e difícil do GNFS está aqui.

O que queremos no final não é o “quadrado de um ideal”, mas o “quadrado de um elemento ($\gamma^2$)” para substituir no mapeamento $\phi$. Só porque se tornou o quadrado de um ideal, não significa necessariamente que o elemento em si é um quadrado. Existem dois fortes obstáculos matemáticos (Obstructions) aqui.

Obstáculo ①: A Barreira do Grupo de Classes de Ideais (Ideal Class Group)

O ideal $I$ nem sempre é um “ideal gerado por um único elemento (ideal principal)”. É impossível extrair um elemento específico $\gamma$ de um ideal que não é principal.

Aqui entra o conceito de “Grupo de Classes de Ideais (Class Group, $Cl_K$)” . O grupo de classes de ideais é um grupo que mede “quantos ideais existem no mundo daquele corpo algébrico que não são principais (o quanto a unicidade da fatoração se quebra)”. Mesmo que $\prod \langle a - b\alpha \rangle$ se torne $I^2$, se $I$ não for o elemento de identidade (ideal principal) no grupo de classes de ideais, ele não pode ser trazido de volta ao quadrado de um elemento.

Obstáculo ②: A Barreira do Grupo de Unidades (Unit Group)

Suponhamos que, por sorte, $I$ fosse o ideal principal $\langle \gamma \rangle$. Então, teríamos $\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$. Você pode pensar, “Ótimo, o elemento também é um quadrado!”, mas isso é um grande erro.

Ideais (conjuntos de múltiplos) sendo iguais não significa que os elementos sejam perfeitamente iguais. Sempre haverá um desvio por uma “Unidade (Unit: um número cujo inverso também é um inteiro. Por exemplo, 1 ou -1)” . Em outras palavras, a verdadeira equação dos elementos se torna assim:

$$\prod_{S} (a - b\alpha) = u \cdot \gamma^2$$

($u$ é um elemento do grupo de unidades $U_K$)

A menos que esta unidade $u$ em si seja o quadrado de algo, o lado esquerdo nunca pode se tornar um “quadrado perfeito de um elemento”.

Fase 5: A Magia de Adleman “Caracteres Quadráticos” (Quadratic Characters)

O obstáculo do grupo de classes de ideais e o obstáculo do grupo de unidades. Como superar esses dois? Aqui entra o brilhante método dos “Caracteres Quadráticos (Quadratic Characters)” , introduzido pelo criptógrafo Leonard Adleman (o “A” do RSA) e outros.

Para determinar “se um certo elemento é um quadrado perfeito no corpo algébrico”, usamos a versão de corpos algébricos do Símbolo de Legendre (resíduo quadratique). Naquela matriz gigante anterior (o quebra-cabeça para tornar pares as contagens de ideais primos), nós furtivamente adicionamos algumas dezenas de condições extras (colunas) dizendo “os caracteres quadráticos para certos ideais primos especiais $\mathfrak{q}$ também devem ser todos $1$ (par)” .

Quando encontramos um conjunto $S$ que satisfaz até mesmo essas condições adicionais através de cálculos de matrizes, teoremas profundos da teoria algébrica dos números garantem que “tanto o obstáculo do grupo de classes de ideais quanto o obstáculo do grupo de unidades desaparecerão naturalmente com uma probabilidade esmagadora” .

Com isso, finalmente obtemos a verdadeira equação.

$$\prod_{S} (a - b\alpha) = \gamma^2$$

Fase Final: A Fusão dos Mundos e o Colapso Criptográfico

Finalmente, todas as peças do quebra-cabeça estão no lugar.

[Elementos no Mundo dos Corpos Algébricos (Mundo A)] $\gamma^2 = \prod (a - b\alpha)$ (Nós usamos um algoritmo de raiz quadrada para encontrar $\gamma$)

[Elementos no Mundo Real (Mundo dos Números Racionais)] $V^2 = \prod (a - bm)$ (Como esta é uma simples multiplicação de inteiros, $V$ é encontrado normalmente)

Agora é hora daquela ponte mágica que construímos no início, o homomorfismo $\phi$ . Nós teleportamos o elemento $\gamma$ do Mundo A para o Mundo B (o mundo dos restos de $N$) usando $\phi$ (o mapeamento onde substituímos $\alpha$ por $m$).

$$Y = \phi(\gamma) \pmod N$$

Por outro lado, levamos o $V$ construído no mundo real diretamente para o mundo dos restos e o chamamos de $X$.

$$X = V \pmod N$$

Devido à propriedade “preservadora de estrutura” do homomorfismo, a relação quadrada que se manteve no Mundo A é perfeitamente preservada no Mundo B (o mundo módulo $N$). Além disso, como os pares originais $(a, b)$ foram feitos em correspondência nas formas $a - b\alpha$ e $a - bm$, estes $X$ e $Y$ colidem no mundo módulo $N$ e produzem a seguinte equação absoluta.

$$X^2 \equiv Y^2 \pmod N$$

Tudo o que resta é rezar para que esses $X$ e $Y$ não sejam soluções triviais ($X \equiv \pm Y$) e calcular $\gcd(X - Y, N)$ .

Se for uma solução não trivial, o algoritmo euclidiano avança em 0.001 segundos, e os números primos secretos $p$ e $q$, que são o coração da criptografia RSA, são impressos na tela de saída.

Este é o quadro completo do “Crivo Geral dos Corpos de Números (GNFS)” , a essência da matemática moderna.

O que é o "General Number Field Sieve (GNFS)", a matemática mais poderosa da humanidade que quebra a criptografia da internet?

Sat, 05 Sep 2026 02:09:08 +0900

O que é o “General Number Field Sieve (GNFS)”, a matemática mais poderosa da humanidade que quebra a criptografia da internet?

A internet que usamos todos os dias. Mensagens no LINE, YouTube, compras na Amazon etc., todas as comunicações são protegidas por “criptografia”. Atualmente, a criptografia mais utilizada em todo o mundo é a “Criptografia RSA”.

O núcleo da defesa da Criptografia RSA é muito simples. Ele utiliza a propriedade matemática de que ** “a fatoração em números primos de números gigantescos não pode ser resolvida nem mesmo por computadores” ** . Por exemplo, para “15”, sabemos imediatamente que é “3 × 5”, mas no instante em que isso se torna um “número de 270 dígitos”, levaria centenas de milhões de anos para ser resolvido, mesmo se conectássemos todos os supercomputadores do mundo.

No entanto, os matemáticos não ficaram em silêncio. Para quebrar essa criptografia impenetrável, a humanidade criou um algoritmo (procedimento de cálculo) quase mágico chamado ** “General Number Field Sieve (GNFS)” ** .

Neste artigo, sem usar nenhum jargão técnico e apenas com o conhecimento da ** matemática do ensino fundamental (fatoração em primos, expressões algébricas, máximo divisor comum) ** , explicaremos passo a passo como esse “algoritmo mais forte da humanidade” quebra a criptografia!

Capítulo 1: O objetivo da decodificação é uma “fórmula da 8ª série”

O maior golpe especial para enfrentar a gigantesca fatoração em números primos. É essa fórmula aprendida na 8ª série:

** $X^2 - Y^2 = (X + Y)(X - Y)$ **

Você pode pensar: “Sério que uma fórmula tão básica pode quebrar a criptografia?”. No entanto, esta é a chave mestra que revela tudo.

O maior objetivo para quebrar a criptografia é, para um número gigante $N$, encontrar ** “números ($X$ e $Y$) onde o resto da divisão de $X^2$ e $Y^2$ por $N$ seja o mesmo” ** .

Por que “ter o mesmo resto” quebra a criptografia?

Suponha que dois números, $X^2$ e $Y^2$, tenham “o mesmo resto quando divididos por $N$”. Ter o mesmo resto significa que existe uma regra onde ** a subtração “$X^2 - Y^2$” será sempre perfeitamente divisível por $N$ (será um múltiplo de $N$) ** .

Aqui, vamos supor que o número gigante $N$ usado na criptografia seja composto pela multiplicação de dois números primos secretos ($p$ e $q$) ($N = p \times q$).

Fatorando $X^2 - Y^2$, obtemos ** $(X - Y)(X + Y)$ ** . O fato de isso ser um múltiplo de $N$ significa que, em algum lugar dessa multiplicação, os primos secretos $p$ e $q$ estão escondidos.

Aqui, um milagre acontece. Há uma probabilidade matemática de ** 50% (metade) ** de que os dois primos $p$ e $q$ se separem em salas diferentes: ** “$p$ vai para a sala de $(X - Y)$” e “$q$ vai para a sala de $(X + Y)$” ** .

Com apenas o primo $p$ tendo entrado na sala de $(X - Y)$, vamos calcular o ** “máximo divisor comum (a maior peça em comum)” ** de $(X - Y)$ e $N$.

Conteúdo de $(X - Y)$ = $p \times$ algum número
Conteúdo de $N$ = $p \times q$ A única peça comum é ** “$p$” ** !

Ou seja, no instante em que o máximo divisor comum é calculado, o número primo oculto $p$ é revelado e a criptografia é completamente decodificada. (*O máximo divisor comum pode ser calculado instantaneamente em um smartphone usando o “Algoritmo de Euclides”).

** 【Pequena Coluna: Por que o quadrado? Cubo ou o dobro não servem?】 **

Com “$2X - 2Y$”, torna-se $2(X - Y)$ e há apenas uma sala, então você não pode separar os primos. Com “$X^3 - Y^3$”, os tamanhos das salas ficam desequilibrados e o cálculo torna-se desnecessariamente pesado. Para separar os primos em dois, o “quadrado” que se divide perfeitamente em duas salas tem o melhor custo-benefício.

Capítulo 2: Como encontrar X e Y? “Quebra-cabeça de coleta de cartas de números primos”

O objetivo é claro. No entanto, mesmo se procurarmos cegamente por “$X^2$ e $Y^2$ que têm o mesmo resto”, o fim do universo chegaria antes de encontrá-los. Então, os matemáticos criaram um método genial chamado ** “quebra-cabeça de coleta de cartas de números primos” ** .

Step 1: Coletar apenas ouro em pó (números suaves) com uma peneira

Primeiro, prepare um número apropriado $Z$, eleve-o ao quadrado e calcule o resto $W$ ao dividi-lo por $N$. (O mundo dos restos de $Z^2 = W$)

Fatore o resto obtido $W$ em números primos. Aqui, apenas quando aparecer ** “um $W$ composto apenas de pequenos primos como 2, 3, 5, 7, etc.” ** , guarde essa equação como um “cartão premiado” e jogue-a fora se houver primos grandes misturados. É como jogar fora as pedras grandes com uma peneira num rio para coletar apenas o pó de ouro.

Step 2: O quebra-cabeça para tornar tudo “par”

Por exemplo, suponha que as 3 seguintes cartas de pó de ouro foram coletadas.

Carta A: $Z_1^2 = 2^3 \times 3^1$
Carta B: $Z_2^2 = 2^1 \times 5^1$
Carta C: $Z_3^2 = 3^1 \times 5^1$

Vamos multiplicar todos eles. O lado direito se torna $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$, E ao organizá-los juntos, obtemos ** “$2^4 \times 3^2 \times 5^2$” ** .

Surpreendentemente, a quantidade de números primos tornou-se “4, 2, 2”, ** todos sendo um número par ** ! O fato de todos serem pares significa que se você reduzir a quantidade total pela metade, será “o quadrado de algo”. Ou seja, $(2^2 \times 3^1 \times 5^1)^2 = (60)^2$.

O lado esquerdo é $(Z_1 \times Z_2 \times Z_3)^2$, então finalmente chegamos a: ** $X = (Z_1 \times Z_2 \times Z_3)$ ** ** $Y = 60$ ** O tão esperado par “$X^2 = Y^2$” está completo!

Para computadores, o quebra-cabeça de calcular se a quantidade de números primos é “par ou ímpar (0 ou 1)” é algo em que eles são muito bons, então, com este método, é possível encontrar $X$ e $Y$ em alta velocidade.

Capítulo 3: A Parede do Desespero se ergue

Agora qualquer criptografia pode ser quebrada! …ou assim pensávamos, mas um grande problema ocorreu. Se o número da criptografia $N$ tiver até cerca de “100 dígitos”, este método (chamado Sieve Quadrático) pode resolvê-lo, mas quando $N$ se torna “200 ou 300 dígitos”, o $W$ que surge no meio do cálculo torna-se demasiado grande.

Quando os números ficam demasiado grandes, “números compostos apenas por pequenos números primos (pó de ouro)” deixam de aparecer. Torna-se mais difícil do que procurar lentes de contacto no deserto, e as cartas necessárias para resolver o quebra-cabeça não se acumulam de forma alguma.

Aqui, a arma final da humanidade, o ** “General Number Field Sieve (GNFS)” ** , finalmente entra em cena.

Capítulo 4: A ideia mais forte da humanidade de criar “Dois Mundos”

A ideia genial do GNFS é: ** “Os números tornam-se gigantescos porque calculamos apenas no mundo real. Então, vamos criar um ‘mundo dos bastidores’ usando polinómios (fórmulas com letras) para dividir o peso do cálculo em dois.” **

A magia das fórmulas com letras

O GNFS converte o número gigante $N$ em uma fórmula com letras, utilizando um número base $m$. Por exemplo, se $N=100$, com $m=4$, então $100 = 4^3 + 2(4^2) + 4$. Transformamos isso numa fórmula (o mundo dos bastidores) usando a letra $x$: ** $f(x) = x^3 + 2x^2 + x$ ** .

O mais interessante dessa fórmula é que ela possui a propriedade de que ** “se substituirmos $x$ por $m$ (4 no exemplo acima), sempre podemos voltar ao número real $N$” ** .

Procurando pó de ouro em 2 mundos simultaneamente

O GNFS cria muitos pares de números inteiros aleatórios $(a, b)$ e realiza os seguintes dois cálculos em simultâneo:

** Mundo Real ** : $a - b \times m$
** Mundo das Letras ** : O valor de $a - b \times x$ calculado pelas regras dos polinómios

Ao dividir o problema em dois mundos, o tamanho dos números tratados diminui (fica mais leve) drasticamente. É como dividir uma pedra gigante em dois para transformá-la em pedras mais fáceis de manusear.

Então, utilizamos uma peneira para separar e recolher apenas os pares milagrosos $(a, b)$ onde ** “tanto no mundo real quanto no mundo das letras, ambos são ‘compostos apenas de pequenos primos (pó de ouro)’” ** . Esta é a origem do nome “Crivo do Corpo de Números”.

O momento em que a criptografia é finalmente quebrada

Quando dezenas de milhões de “cartões de pó de ouro” são recolhidos de ambos os mundos, o supercomputador utiliza cálculos gigantescos de matrizes para encontrar “uma combinação em que o número de primos seja todo par”, tal como fizemos no Capítulo 2.

Assim que a combinação for encontrada:

Deixe o número ao quadrado no mundo real ser ** $X^2$ **
Deixe a fórmula quadrada criada no mundo das letras ser ** $Y(x)^2$ **

Por fim, substitua $x$ na fórmula de letras $Y(x)$ por $m$, saltando de volta para o mundo real e unindo-os. Então, como que por magia matemática, a condição onde ** “os restos de $X^2$ e $Y^2$ são iguais” ** é estritamente alcançada!

O resto, como no Capítulo 1, é apenas calcular o máximo divisor comum entre $X - Y$ e $N$, e a impenetrável criptografia RSA desmoronará, revelando os primos secretos.

Conclusão: A matemática não acaba

Você pode estar a pensar: “Fantástico, com o GNFS qualquer criptografia pode ser quebrada!”. No entanto, a criptografia RSA também não se deu por vencida. O que é utilizado na internet atual é um número gigantesco e monstruoso chamado “RSA-2048 (cerca de 617 dígitos)”.

Por mais que o GNFS seja o algoritmo mais poderoso da humanidade, diz-se que para resolver até mesmo 270 dígitos (RSA-270), levaria milhares ou dezenas de milhares de anos, mesmo conectando computadores do mundo inteiro. Por agora, os nossos dados bancários e do LINE estão seguros.

Mas e se aparecesse uma ** “magia capaz de encontrar instantaneamente $X$ e $Y$ para qualquer número gigante” ** ? Na verdade, a coisa mais próxima disso é o ** “Computador Quântico (Algoritmo de Shor)” ** , que está atualmente em desenvolvimento. Utilizando a natureza ondulatória da mecânica quântica, foi provado matematicamente que é possível ignorar o aborrecido quebra-cabeças da recolha de cartas e chegar à resposta de uma só vez.

A interminável batalha de inteligência entre os que criam a criptografia (defesa) e os que criam algoritmos para a quebrar (ataque). Saber que a “fatoração em números primos” e as “fórmulas com letras” ensinadas na escola secundária são, na verdade, as armas na linha da frente da segurança global não faz com que as aulas de matemática pareçam um pouco mais interessantes?

Quem descobrirá o algoritmo mais forte do futuro poderá ser você, que está a ler este artigo!

(※Este artigo é uma adaptação conceptual do encanto matemático da quebra de códigos para estudantes. O GNFS real é rigorosamente calculado utilizando matemática universitária avançada, tal como os grupos da classe de ideais dos corpos numéricos algébricos e homomorfismos)

【Compreensão Completa com Fórmulas】Por que o 'GNFS', o mais forte algoritmo clássico, é derrotado pelos algoritmos quânticos? A mudança de paradigma da fatoração

Mon, 01 Jan 0001 00:00:00 +0000

A segurança da informação na sociedade da internet moderna é protegida por sistemas de criptografia de chave pública, como a criptografia RSA. A base para a segurança da criptografia RSA depende do fato de que “a fatoração de números compostos gigantescos é computacionalmente extremamente difícil” .

Neste artigo, desvendaremos o mecanismo matemático do “Crivo do Corpo de Números Generalizado” (General Number Field Sieve, GNFS), que é o algoritmo de fatoração mais poderoso em computadores clássicos, e aprofundaremos minuciosamente, usando fórmulas matemáticas e diagramas conceituais, a mudança de paradigma de por que ele é completamente superado pelo “Algoritmo de Shor” , descoberto por Peter Shor.

1. A abordagem da fatoração na computação clássica: Evolução do método de fatoração de Fermat

O problema da fatoração de inteiros é o problema de encontrar os números primos $p, q$ tais que $N = p \times q$ , para um dado número composto $N$ .

A ideia básica se resume a encontrar valores não triviais $x, y$ que satisfaçam a seguinte congruência.

$$ x^2 \equiv y^2 \pmod N $$

Rearranjando isto, temos:

$$ x^2 - y^2 \equiv 0 \pmod N $$ $$ (x - y)(x + y) \equiv 0 \pmod N $$

Aqui, se $x \not\equiv \pm y \pmod N$ , podemos calcular o $\gcd(x-y, N)$ ou $\gcd(x+y, N)$ para obter um fator não trivial de $N$ . Este fato forma a base dos algoritmos de fatoração modernos, como o GNFS.

2. O algoritmo clássico mais forte: O abismo do “Crivo do Corpo de Números Generalizado” (GNFS)

O GNFS é o algoritmo de fatoração mais rápido conhecido hoje para computadores clássicos. Sua complexidade de tempo requer um tempo subexponencial (Sub-exponential).

Complexidade de tempo do GNFS

Quando o número de dígitos de $N$ é $b = \log_2 N$ , a complexidade de tempo do GNFS é expressa da seguinte forma:

$$ O\left( \exp \left( \left(\frac{64}{9} b\right)^{1/3} (\log b)^{2/3} \right) \right) $$

Como pode ser visto nesta fórmula, a complexidade não é tempo polinomial, mas sim um “tempo subexponencial” que é ligeiramente mais lento que uma função exponencial. Ainda assim, à medida que o número de dígitos aumenta, o tempo de computação cresce astronomicamente.

Mecanismo matemático do GNFS

O GNFS consiste principalmente em 4 etapas.

Seleção de Polinômios (Polynomial Selection)
Crivagem (Sieving)
Redução de Matriz (Matrix Reduction)
Cálculo da Raiz Quadrada (Square Root)

2.1. Seleção de Polinômios e Corpo Algébrico

Primeiro, escolhemos polinômios irredutíveis $f(x)$ e $g(x)$ com coeficientes inteiros. Eles são configurados para ter uma raiz comum $m$ módulo $N$ . Ou seja,

$$ f(m) \equiv 0 \pmod N $$ $$ g(m) \equiv 0 \pmod N $$

Geralmente, $g(x)$ é escolhido como um polinômio de primeiro grau $g(x) = x - m$ . Se a raiz de $f(x)$ for $\alpha$ , construímos um “corpo de números” (Number Field) chamado $\mathbb{Q}(\alpha)$ . As operações no anel de $\mathbb{Q}(\alpha)$ e as operações no anel comum de inteiros $\mathbb{Z}$ são comparadas através do homomorfismo $\phi: \alpha \mapsto m$ .

2.2. Crivagem (Sieving)

Em seguida, procuramos por uma grande quantidade de pares de inteiros coprimos $(a, b)$ . O objetivo é encontrar pares em que os dois valores a seguir sejam “B-smooth” (compostos apenas por fatores primos relativamente pequenos).

$a - bm$ (valor sobre o anel de inteiros)
$b^d f(a/b)$ (correspondente à norma $N(a - b\alpha)$ sobre o corpo algébrico)

Aqui é usado um método de busca rápido chamado “crivo” (Sieve). Isso extrai eficientemente pares $(a, b)$ que satisfazem as condições de um enorme número de candidatos.

2.3. Redução de Matriz (Linear Algebra over GF(2))

A partir dos pares coletados $(a, b)$ , construímos vetores de expoentes e encontramos o espaço nulo à esquerda de uma enorme matriz esparsa sobre $\mathbb{F}_2$ (um corpo cujos elementos são apenas 0 e 1).

Encontramos o vetor $v$ como uma solução tal que as relações $ \prod (a_i - b_i m) $ e $ \prod (a_i - b_i \alpha) $ se tornem quadrados perfeitos. Isto não é nada mais do que resolver o seguinte sistema de equações lineares:

$$ M \mathbf{x} \equiv \mathbf{0} \pmod 2 $$

Aqui, algoritmos avançados de cálculo numérico, como o Algoritmo de Block Lanczos ou o Algoritmo de Block Wiedemann, são utilizados.

2.4. Cálculo da Raiz Quadrada

Por fim, extraímos a raiz quadrada tanto no corpo algébrico quanto no anel de inteiros para derivar a relação $x^2 \equiv y^2 \pmod N$ . Em seguida, calculamos $\gcd(x-y, N)$ para obter os fatores.

3. Um avanço revolucionário pela computação quântica: “Algoritmo de Shor”

Enquanto o GNFS requer tempo subexponencial, o “Algoritmo de Shor” , publicado por Peter Shor em 1994, pode resolver esse problema em “tempo polinomial” usando um computador quântico.

Complexidade do Algoritmo de Shor

Assumindo que o número de qubits seja $O(\log N)$ , a complexidade de tempo é a seguinte:

$$ O((\log N)^3) $$

Isso significa que não há explosão exponencial em relação ao número de bits. É um resultado surpreendente: mesmo para números compostos gigantescos onde o tempo para a “computação clássica” excederia a idade do universo, a “computação quântica” pode descriptografá-los em questão de horas ou dias.

Visão geral do Algoritmo de Shor: Redução ao problema da descoberta de período

O Algoritmo de Shor reduz inteligentemente o problema de fatoração em primos a um “problema de descoberta de período” .

Escolha um inteiro aleatório $a$ que seja coprimo com $N$ ( $1 < a < N$ ).
Defina a função $f(x) = a^x \bmod N$ .
Encontre o período $r$ de $f(x)$ , ou seja, o menor inteiro positivo $r$ tal que $a^r \equiv 1 \pmod N$ .
Se $r$ for par, verifique se $a^{r/2} \not\equiv -1 \pmod N$ , calcule $\gcd(a^{r/2} \pm 1, N)$ e obtenha o fator primo.

Esta “descoberta do período $r$ “ na etapa 3 é o gargalo que leva tempo exponencial em computadores clássicos, mas os computadores quânticos resolvem isso instantaneamente usando a “sobreposição quântica” e a “Transformada de Fourier Quântica” (QFT).

4. Transformada de Fourier Quântica (QFT) e Extração de Período

Vejamos mais de perto as fórmulas matemáticas sobre a manipulação de estados quânticos, que é o núcleo do Algoritmo de Shor.

4.1. Geração de Sobreposição Quântica

Primeiro, preparamos dois registradores quânticos. O Registrador 1 mantém o estado de sobreposição das entradas $x$ , e o Registrador 2 mantém os resultados calculados da função $f(x)$ . Aplicamos a Transformada de Hadamard (Hadamard Transform) ao estado inicial $|0\rangle |0\rangle$ para criar uma sobreposição de todos os possíveis $x$ .

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle |0\rangle $$

(onde $Q$ é uma potência de 2 satisfazendo $N^2 \le Q < 2N^2$ )

Em seguida, usamos o oráculo quântico $U_f$ para calcular $f(x) = a^x \bmod N$ e armazená-lo no Registrador 2.

$$ |\psi_2\rangle = U_f |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle |a^x \bmod N\rangle $$

Suponhamos agora que medimos o Registrador 2 (embora na realidade a estrutura matemática seja a mesma mesmo sem medição). Se observarmos um determinado valor $y = a^{x_0} \bmod N$ , o estado do Registrador 1 colapsa para uma sobreposição de todos os $x$ onde $f(x) = y$ . Se o período for $r$ , esses $x$ serão $x_0, x_0 + r, x_0 + 2r, \dots$

$$ |\psi_3\rangle = \frac{1}{\sqrt{M}} \sum_{k=0}^{M-1} |x_0 + kr\rangle $$

(onde $M \approx Q/r$ é o número de termos)

Este estado contém inerentemente a informação sobre o período $r$ , mas medir isso diretamente apenas nos dá um $x_0 + kr$ aleatório, não revelando $r$ . É aqui que entra a QFT.

4.2. Aplicação da Transformada de Fourier Quântica (Quantum Fourier Transform)

A QFT é uma operação que aplica uma transformada discreta de Fourier às amplitudes do estado quântico. A ação da QFT no estado $|x\rangle$ é definida como segue:

$$ \text{QFT} |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} e^{2\pi i \frac{xy}{Q}} |y\rangle $$

A aplicação disto a $|\psi_3\rangle$ induz interferência de fase (interferência quântica).

$$ |\psi_4\rangle = \text{QFT} |\psi_3\rangle = \frac{1}{\sqrt{MQ}} \sum_{y=0}^{Q-1} \sum_{k=0}^{M-1} e^{2\pi i \frac{(x_0 + kr)y}{Q}} |y\rangle $$

Ao expandir o somatório desta equação, surge a parte:

$$ \sum_{k=0}^{M-1} e^{2\pi i \frac{kry}{Q}} $$

Esta soma da série geométrica reforça-se mutuamente (Interferência Construtiva) apenas quando $ry/Q$ é próximo a um número inteiro e se cancela em outros momentos (Interferência Destrutiva).

Portanto, o estado $|y\rangle$ medido com alta probabilidade será um número inteiro $y$ que satisfaz a condição:

$$ \frac{y}{Q} \approx \frac{c}{r} $$

(onde $c$ é algum inteiro).

4.3. Identificação do Período por Expansão em Frações Contínuas

Após obter $y$ pela medição, utilizamos um computador clássico para realizar a “expansão em frações contínuas” (Continued Fraction Expansion) de $y/Q$ . Isso nos permite calcular a fração aproximada $c/r$ de $y/Q$ e extrair de forma altamente eficiente os candidatos ao período $r$ a partir do denominador.

5. Comparação de Modelos Conceituais e Mudança de Paradigma

Para entender intuitivamente a diferença entre o GNFS e o Algoritmo de Shor, mostramos um diagrama conceitual usando a notação Mermaid.

Diagrama conceitual do Algoritmo de Shor via circuito quântico

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


graph TD
 A[Estado inicial: 0...0] --> B[Sobreposição de todos os estados por Transformada de Hadamard]
 B --> C[Exponenciação modular a^x mod N]
 C -->|Emaranhamento quântico| D[Colapso para um estado com periodicidade]
 D --> E[Transformada de Fourier Quântica QFT]
 E -->|Amplificação de probabilidade por interferência| F[Medição: obter y]
 F --> G[Processamento clássico: expansão em frações contínuas]
 G --> H[Descoberta do período r]
 H --> I[Cálculo dos fatores primos de N]

 style A fill:#f9f,stroke:#333,stroke-width:2px
 style E fill:#bbf,stroke:#333,stroke-width:2px
 style I fill:#bfb,stroke:#333,stroke-width:2px

A essência da mudança de paradigma

O GNFS adota uma abordagem que consiste em “buscar relações dentro de um espaço matemático (corpo algébrico)” . No entanto, como o espaço de busca se expande exponencialmente em relação ao número de dígitos, com as capacidades computacionais clássicas (incluindo paralelização), a decodificação se torna quase impossível quando o tamanho da chave excede os 2048 bits.

Por outro lado, o Algoritmo de Shor utiliza a “natureza de onda devido à interferência quântica” . Ele avalia simultaneamente todos os caminhos computacionais na sobreposição de estados e usa a QFT para cancelar respostas desnecessárias (interferência destrutiva) enquanto amplifica apenas a amplitude de probabilidade do período correto (interferência construtiva). Com isso, ao invés de buscar no espaço, atinge uma abordagem de dimensão completamente diferente onde “surge a própria resposta correta” .

6. Conclusão

Neste artigo, aprofundamo-nos nos contextos matemáticos e nas estruturas de algoritmos, comparando o “GNFS” , o pico absoluto do limite clássico, com o “Algoritmo de Shor” , que demonstra o poder da computação quântica.

Enquanto o GNFS usa técnicas matemáticas sofisticadas, como a escolha de polinômios e cálculos matemáticos com grandes matrizes, para reduzir o tempo computacional a um tempo subexponencial, o Algoritmo de Shor combina os princípios fundamentais da mecânica quântica, sobreposição e interferência, com ferramentas matemáticas (QFT) para produzir um avanço instantâneo ao tempo polinomial.

No momento, não existe nenhum computador quântico tolerante a falhas (FTQC) capaz de executar o Algoritmo de Shor em escala prática (milhares de qubits). No entanto, a própria existência dessa mudança de paradigma matemático e teórico é a principal razão pela qual há atualmente uma rápida e urgente transição para a Criptografia Pós-Quântica (PQC: Post-Quantum Cryptography) no mundo todo.