GNFS on kenji.blog

[Análisis completo] Implementando y entendiendo el algoritmo de descifrado más fuerte 'GNFS' en C++

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

【Análisis Completo】Entendiendo el algoritmo de descifrado más fuerte “GNFS” implementándolo en C++

El cifrado “RSA” es la base que sostiene la Internet moderna. Su robustez depende de la creencia matemática de que “factorizar un número compuesto gigante en números primos es virtualmente imposible con las computadoras actuales”.

Sin embargo, la humanidad nunca se rinde. Actualmente, existe el **algoritmo más fuerte y avanzado de la humanidad ** para realizar factorizaciones gigantescas en computadoras clásicas (computadoras normales, no cuánticas). Este es el “General Number Field Sieve (GNFS) o Criba General del Cuerpo de Números”.

En este artículo, publicaremos todo el código de implementación que modela estrictamente la lógica computacional más avanzada de GNFS en C++ (usando enteros de precisión múltiple boost::multiprecision de la biblioteca Boost), y explicaremos a fondo los abismos de la “teoría algebraica de números” detrás de él.

Por favor, disfruten del misterio de las matemáticas y del poder de la ciencia computacional que lo domina, junto con el código fuente.

1. GNFS Framework Lógico de Vanguardia (Código fuente completo)

Primero, aquí está la visión general de la implementación de GNFS en C++ que explicaremos. La criba de cuerpo de números real (como CADO-NFS) es un sistema distribuido masivo de cientos de miles de líneas de código, pero este código diseña y modela las “5 tuberías (fases) esenciales” que componen GNFS en clases, manteniéndolo en una configuración mínima sin perder su 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


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

// Usando enteros de precisión múltiple de Boost.Multiprecision
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve (Criba General del Cuerpo de Números) Framework Lógico de Vanguardia
//
// Este código modela estrictamente las 5 tuberías del GNFS más avanzado utilizado en CADO-NFS, etc.,
// como diseño de clases en C++ (Boost).
// ============================================================================

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

// ============================================================================
// Fase 1: Selección Polinomial (Algoritmo de KleinJung)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // Polinomio lado algebraico f(x)
 std::vector<cpp_int> g; // Polinomio lado racional g(x) = x - m
 cpp_int m;

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

 // Generación del polinomio inicial basado en expansión en base m (En realidad se usa reducción de bases de retículos LLL más avanzada)
 void select(const cpp_int& N) {
 std::cout << "[Fase 1] Polynomial Selection (Grado " << degree << ") iniciando..." << std::endl;
 // Expansión simple en base m (grado d)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // Aproximación simple de m (sin usar funciones de 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] Completo." << std::endl;
 }
};

// ============================================================================
// Fase 2: Lattice Sieving (Criba de Retículos)
// ============================================================================
// En el GNFS moderno, el estándar de facto no es Line Sieve (Criba Lineal), sino
// la Criba de Retículos q-Especial (Special-q Lattice Sieving) de Franke-Kleinjung y otros.
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] Generando Factor Bases (Límite Racional: " << rational_bound << ", Límite Algebraico: " << algebraic_bound << ")" << std::endl;
 // (Omitido) En realidad realiza generación de primos y filtrado con el símbolo de Legendre, etc.
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Fase 2] Special-q Lattice Sieving activo..." << std::endl;
 std::vector<Relation> relations;
 // Implementación Mock: La criba de retículos real escanea cientos de GB de espacio de memoria en bloques,
 // mapea pares (a, b) a retículos para cada primo especial q (a = i*q + j*...),
 // y ejecuta un sieving (criba) maximizando la eficiencia de la caché al extremo.

 // Añadiendo una relación dummy para la demo
 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() << " relaciones." << std::endl;
 return relations;
 }
};

// ============================================================================
// Fase 3: Filtering (Purga de singletons y mezcla de cliques)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Fase 3] Filtrando Relaciones..." << std::endl;
 // 1. Eliminación de Singletons (eliminación de relaciones con primos que aparecen solo 1 vez)
 // 2. Fusión de Cliques (combinación de relaciones para hacer densa una matriz dispersa)
 // En realidad, comprime una matriz de cientos de millones de filas a unos pocos millones usando algoritmos como Union-Find.
 std::cout << "[Fase 3] Tamaño de la matriz reducido óptimamente." << std::endl;
 }
};

// ============================================================================
// Fase 4: Álgebra Lineal sobre GF(2) (Método Block Wiedemann)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // En los entornos de supercomputadoras recientes, se utiliza como vanguardia el método Block Wiedemann
 // (implementación de Coppersmith) que es más adecuado para computación distribuida que el método Block Lanczos.
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Fase 4] Algoritmo Block Wiedemann sobre GF(2) iniciando..." << std::endl;
 // Repite la operación de producto de matrices dispersas y vectores,
 // y encuentra múltiples vectores solución (kernels) donde M * x = 0 mod 2.

 std::vector<std::vector<int>> dependencies; // Lista de dependencias
 // Datos dummy
 dependencies.push_back({0});

 std::cout << "[Fase 4] Encontradas " << dependencies.size() << " dependencias lineales (cuadrados perfectos)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Fase 5: Raíz Cuadrada Algebraica (Algebraic Square Root)
// ============================================================================
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] Computación de Raíz Cuadrada Algebraica..." << std::endl;

 // 1. Cálculo de la raíz cuadrada racional V (operación de enteros simple)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. Cálculo de la raíz cuadrada algebraica gamma (Método de Montgomery, etc.)
 // Encuentra el elemento gamma del cuerpo algebraico gigante O_K, y lo mapea al mundo real con el homomorfismo phi
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // Asumiendo que se añadieron columnas de Caracteres Cuadráticos (Quadratic Characters) en la Fase 2 y 4
 // para evitar la obstrucción del grupo de clases de ideales y el 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 << "[ÉXITO] Factor no trivial encontrado: " << factor << std::endl;
 std::cout << " Otro factor: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[FALLO] Solución trivial. Probando la siguiente dependencia..." << std::endl;
 }
 }
};

// ============================================================================
// Pipeline de Ejecución Principal
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] Motor General Number Field Sieve (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // Número compuesto gigante N que queremos factorizar, ej. RSA-270
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // Grado del polinomio (para más de 130 dígitos usualmente se selecciona grado 5 a 6)
 int degree = 6;

 // Inicialización del pipeline
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // Los límites reales son decenas a cientos de millones
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

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

 // 1. Selección Polinomial
 poly_select.select(N);

 // 2. Proceso de Criba (Sieving)
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. Filtrado (Compresión de matriz)
 filter.reduce_matrix(relations);

 // 4. Álgebra Lineal (Búsqueda del espacio nulo sobre GF(2))
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. Cálculo de Raíz Cuadrada Algebraica y 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 SOTA GNFS completado en " << elapsed.count() << " segundos." << std::endl;

 return 0;
}

Entonces, ¿cómo es que este código destruye los muros de la criptografía? Explicaremos los minuciosos algoritmos y las matemáticas avanzadas para cada una de las 5 fases.

2. El objetivo final de GNFS: $X^2 \equiv Y^2 \pmod N$

El objetivo de la mayoría de los algoritmos de factorización gigante moderna, no solo de GNFS, es encontrar un par no trivial $(X, Y)$ que satisfaga la siguiente congruencia:

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

Esta fórmula significa que “los restos al dividir $X^2$ y $Y^2$ por $N$ son iguales”. Reorganizando esto: $X^2 - Y^2 \equiv 0 \pmod N$ En otras palabras, $(X-Y)(X+Y)$ es un múltiplo de $N$.

Si $X \not\equiv \pm Y \pmod N$ (solución no trivial), existirá un “divisor común mayor que 1 y menor que $N$” entre $(X-Y)$ y $N$. Aquí, si usamos el algoritmo de Euclides para calcular $\gcd(X-Y, N)$, podemos encontrar los factores primos de $N$ con mucha facilidad.

Sin embargo, encontrar estos $X$ e $Y$ es como buscar una aguja en un desierto. Por lo tanto, GNFS adopta el ingenioso enfoque de crear dos mundos, el “mundo de los enteros reales” y el “mundo de los cuerpos algebraicos de los polinomios”, y distribuye los cálculos.

3. Fase 1: Selección 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) y expansión en base m
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

El primer paso de GNFS es crear un “polinomio mágico” que sirva de puente entre los dos mundos. Para un número gigante $N$, elegimos un entero $m$. Usualmente se elige de tal manera que $m \approx N^{1/d}$ (el código asume un polinomio de grado $d=6$).

Luego, expandimos $N$ en base $m$ y usamos esos coeficientes para construir el polinomio $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 polinomio $f(x)$ tiene una propiedad extremadamente importante: “al sustituir la variable $x$ con $m$, resulta ser exactamente $N$ ($f(m) = N$)”. En otras palabras, $f(m) \equiv 0 \pmod N$. El polinomio en el lado racional se define como $g(x) = x - m$.

Con esto, el “mundo del cuerpo algebraico $\mathbb{Z}[\alpha]$” dominado por la raíz $\alpha$ de $f(x)=0$ y el “mundo normal de los racionales (enteros) $\mathbb{Z}$” quedan firmemente conectados por un “homomorfismo de anillos” (Homomorphism) de $x \to m$.

En herramientas de vanguardia como CADO-NFS, el polinomio “más conveniente $f(x)$” donde los coeficientes no se vuelven extremadamente grandes y es probable que aparezcan primos en pasos posteriores (más fácil que sea liso), se busca durante meses utilizando el algoritmo de KleinJung y el algoritmo de reducción de bases de retículos LLL.

4. Fase 2: Criba de Retículos q-Especial (Special-q Lattice Sieving)

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // mapea pares (a, b) a retículos para cada primo especial q,
 // y ejecuta un sieving (criba) maximizando la eficiencia de la caché al extremo.
 // ...
 }
};

Una vez preparados ambos mundos, el siguiente paso es buscar “números lisos” (números formados solo por factores primos pequeños) en ambos mundos. Generamos infinitos pares de enteros $(a, b)$ y calculamos los siguientes dos valores:

Valor racional: $a - bm$
Norma algebraica: $b^d f(a/b)$

El propósito de GNFS es recolectar de decenas a cientos de millones de estos “pares donde tanto el valor racional como el algebraico pueden descomponerse completamente en factores primos pequeños (Relation: relaciones)”.

En los primeros GNFS, se utilizaba una “Criba Lineal (Line Sieve)” que alineaba $(a, b)$ en el plano $xy$ y dividía por primos desde un extremo. Sin embargo, esto causaba muchas fallas de caché al acceder a la memoria en todas partes, y tenía la debilidad de ser muy lento.

Por lo tanto, el código de vanguardia actual utiliza un método llamado “Criba de Retículos q-Especial (Special-q Lattice Sieve)”. Se fija un número primo $q$ moderadamente grande y solo se consideran “los pares $(a, b)$ donde el valor algebraico siempre es divisible por $q$”. Dado que estos $(a, b)$ forman un “retículo (Lattice)” en el plano, el tamaño del salto de la dirección calculada es constante y se ajusta perfectamente a las memorias caché L1/L2 de la CPU. Gracias a la introducción de esta criba de retículos, la velocidad de cálculo de GNFS ha mejorado drásticamente.

5. Fase 3: Filtrado (Filtering)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Eliminación de Singletons (eliminación de relaciones con primos que aparecen solo 1 vez)
 // 2. Fusión de Cliques (combinación de relaciones para hacer densa una matriz dispersa)
 }
};

Cientos de millones de relaciones recolectadas durante meses por computadoras de todo el mundo en la Fase 2. Sin embargo, si metemos esto directamente en el siguiente “paso de resolución de ecuaciones simultáneas (cálculo matricial)”, la memoria de la supercomputadora estallará.

Por eso, se realiza un proceso de supercompresión de la matriz llamado Filtering (Filtrado).

Eliminación de Singletons (Singleton removal / Purga de singularidades) Suponga que un primo gigante $p$ aparece “solo 1 vez” entre cientos de millones de relaciones. Dado que nuestro objetivo es “hacer que los exponentes de todos los primos sean pares (múltiplos de 2)”, un primo que aparece solo 1 vez nunca podrá hacerse par. Por lo tanto, las relaciones que contienen ese primo se eliminan instantáneamente (se purgan) por considerarse “basura inútil”. A medida que esto ocurre en cadena, los datos de cientos de millones de filas se reducen rápidamente.
Fusión de Cliques (Clique merging) Además, multiplicar (sumar) relaciones que comparten un número primo específico reduce el número de filas al tiempo que comprime una matriz dispersa en un estado más denso (se utiliza una técnica similar a la búsqueda de cliques en la teoría de grafos).

Con esta optimización, la enorme matriz dispersa se comprime drásticamente a un tamaño computable.

6. Fase 4: Álgebra Lineal sobre 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) {
 // Repite la operación de producto de matrices dispersas y vectores,
 // y encuentra múltiples vectores solución (kernels) donde M * x = 0 mod 2.
 }
};

Por fin, el núcleo del rompecabezas. Multiplicamos las relaciones recolectadas para buscar “combinaciones donde los exponentes de los factores primos sean todos números pares”.

Matemáticamente, esto no es más que encontrar un vector solución $x$ (espacio nulo/kernel) usando una matriz gigante $M$ cuyos elementos son “par/impar (es decir, 0 o 1)” de los exponentes de cada primo y un vector $x$ que indica qué relaciones utilizar: $M \cdot x \equiv 0 \pmod 2$

Tenemos que resolver un sistema de ecuaciones de una matriz de tamaño absurdo de millones de filas × millones de columnas. Con el método normal de eliminación de Gauss, la complejidad sería $O(N^3)$, y el cálculo no terminaría hasta el final del universo.

Por lo tanto, la implementación más avanzada utiliza el “Método Block Wiedemann (Bloque Wiedemann)”. Este es un tipo de método del subespacio de Krylov que aprovecha el hecho de que la matriz $M$ es “extremadamente dispersa (casi toda ceros)” y deriva la solución iterando la multiplicación de matriz y vector. A diferencia del antiguo método Block Lanczos, el método Block Wiedemann puede dividir completamente el proceso de cálculo en múltiples grupos, por lo que ejerce un poder abrumador en la computación en nube distribuida moderna y en la computación paralela en supercomputadoras.

7. Fase 5: Raíz Cuadrada Algebraica (Algebraic Square Root) y el Colapso de la Criptografía

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


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. Cálculo de la raíz cuadrada racional V
 cpp_int V = 1;

 // 2. Cálculo de la raíz cuadrada algebraica gamma
 cpp_int Y = 1;

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

A través de los cálculos matriciales de la Fase 4, hemos obtenido un “conjunto de relaciones $S$ que al multiplicarse hacen que todos los factores primos tengan potencias pares”. Con esto, podemos construir el “cuadrado” en ambos mundos, el racional y el algebraico.

Para el lado racional, es simplemente una multiplicación de enteros, por lo que calcular la raíz cuadrada $V$ es fácil.

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

Sin embargo, el verdadero infierno reside en el “lado algebraico”. En el mundo del cuerpo algebraico $\mathbb{Z}[\alpha]$, dado que la factorización única de factores primos no es válida, hemos estado calculando usando ideales. Lo único que garantiza el cálculo matricial es que “es el cuadrado de un ideal”, y no se garantiza que sea “el cuadrado de un elemento ($\gamma^2$)”.

Aquí se levantan poderosos muros en la teoría algebraica de números llamados “obstrucción del grupo de clases de ideales” y “obstrucción del grupo de unidades”. Para romper este muro, GNFS utiliza la magia llamada “Caracteres Cuadráticos (Quadratic Characters)”. A la matriz de la Fase 4, se añaden secretamente de antemano columnas de residuos cuadráticos (Símbolo de Legendre) para decenas de ideales primos especiales. Con esto, hay una probabilidad abrumadora de que el conjunto $S$ encontrado evite la obstrucción y forme con éxito el “cuadrado del elemento verdadero $\gamma^2$”.

El proceso de encontrar $\gamma$ (raíz cuadrada algebraica) se calcula utilizando algoritmos muy complejos como el método de Montgomery.

Y por fin, la raíz cuadrada algebraica $\gamma$ es teletransportada al mundo real (sustituyendo $m$ por $x$) mediante el homomorfismo de anillos $\phi$, y obtenemos $Y$. Si ponemos el $V$ del lado racional directamente como $X$, la ecuación absoluta que hemos estado buscando finalmente se completa.

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

Solo queda calcular $\gcd(X-Y, N)$. En el momento en que se ejecuta el proceso de 0.001 segundos y el factor no trivial se imprime en la pantalla, el cifrado RSA, que se jactaba de ser inexpugnable, colapsa por completo.

Conclusión

GNFS no es simplemente una técnica de programación. Es el cristal del intelecto humano que ha dominado el “abismo de las matemáticas puras” como el álgebra abstracta, la teoría de anillos y los grupos de clases de ideales, con la “ingeniería extrema” como la arquitectura distribuida de supercomputadoras y la optimización de cachés.

La información de chat y de tarjetas de crédito que enviamos de manera informal está protegida sobre una defensa matemática tan astronómica.

Esperamos que, a través de este framework de C++, hayan sentido el “romanticismo de las matemáticas y la informática” detrás del algoritmo de descifrado más avanzado.

La verdadera estructura matemática de la Criba General del Cuerpo de Números (GNFS)

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

La verdadera estructura matemática de la Criba General del Cuerpo de Números (GNFS)

El objetivo final de GNFS es encontrar $X, Y$ tales que $X^2 \equiv Y^2 \pmod N$. Para lograr esto, los matemáticos construyeron un puente entre el “mundo real de los números enteros” y el “mundo de los cuerpos algebraicos”. Ese puente es el “homomorfismo”.

Etapa 1: Conectando mundos con el “Homomorfismo” (Homomorphism)

1. Selección de polinomios y definición de raíces

Para un número compuesto gigante $N$, elegimos un entero $m$ y un polinomio $f(x)$ de manera que $f(m) \equiv 0 \pmod N$. (Ejemplo: expandimos $N$ en base $m$, y formamos $f(x)$ a partir de sus coeficientes. Aquí asumimos que $f(x)$ es irreducible sobre el cuerpo de los números racionales $\mathbb{Q}$ (no se puede factorizar más)).

A continuación, definimos una de las “raíces complejas” de la ecuación $f(x) = 0$ como $\alpha$. Naturalmente, $f(\alpha) = 0$. $\alpha$ no es un entero, sino un número complejo (número algebraico) que puede incluir raíces o números imaginarios.

2. Construcción de Anillos (Rings) y Homomorfismos

Aquí preparamos dos “anillos” matemáticos (mundos donde se definen la suma y la multiplicación):

Mundo A: $\mathbb{Z}[\alpha]$ (el anillo de enteros algebraicos que contiene a $\alpha$) Un mundo de números expresados en la forma $a + b\alpha + c\alpha^2 + \dots$.
Mundo B: $\mathbb{Z}/N\mathbb{Z}$ (el anillo de restos módulo $N$) Un mundo de congruencias (módulos) compuesto solo por números enteros del $0$ al $N-1$.

Aquí, definimos el siguiente mapeo (función) $\phi$ del Mundo A al Mundo B: $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

Este mapeo $\phi$ es una operación mágica que reemplaza exactamente la variable $\alpha$ del Mundo A por el entero $m$ del Mundo B. Este $\phi$ tiene una propiedad extremadamente poderosa llamada “Homomorfismo de Anillos” (Ring Homomorphism). Un homomorfismo es la propiedad de “transportarse a otro mundo sin destruir la estructura de sumas y multiplicaciones”. Es decir, se cumplen las siguientes ecuaciones:

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

Qué significa esto. Si podemos crear un “cuadrado ($\gamma^2$)” de algún elemento complejo $\gamma$ en el “Mundo A (el mundo de $\alpha$)”, al transportarlo al “Mundo B (el mundo de los restos)” con $\phi$, ** la forma del cuadrado $\phi(\gamma)^2$ se conservará perfectamente**.

Etapa 2: El colapso de la factorización prima y el nacimiento del “Ideal” (Ideal)

Queremos recolectar muchos elementos apropiados $(a - b\alpha)$ dentro del Mundo A ($\mathbb{Z}[\alpha]$) y multiplicarlos juntos para crear un “cuadrado perfecto”. Normalmente, factorizaríamos cada $(a - b\alpha)$ en “factores primos” y los combinariamos para que los exponentes de los números primos sean todos pares (resolviéndolo con matrices) para formar un cuadrado.

Sin embargo, aquí nos encontramos con un muro algebraico desesperante. En un mundo de cuerpos algebraicos como $\mathbb{Z}[\alpha]$, se derrumba la “unicidad de la factorización prima” (la idea que nos enseñaron de que cualquier número puede expresarse como el producto de números primos de una sola manera).

(Ejemplo: en cierto mundo de cuerpos algebraicos, $6 = 2 \times 3$, y al mismo tiempo $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$, haciendo imposible saber cuáles son los verdaderos primos).

Si la factorización prima no es única, el rompecabezas de “contar el número de primos para hacerlos pares” (la criba) es en principio imposible de ejecutar.

La salvación de Kummer y Dedekind: el “Ideal”

Lo que salvó a las matemáticas de este colapso fue el concepto de “Ideal” (número ideal) creado por los matemáticos del siglo XIX. Al pensar en el “conjunto de múltiplos (ideal)” generado por un elemento en lugar del elemento en sí, volvieron a hacer posible la factorización prima.

En el anillo de enteros de un cuerpo algebraico $\mathcal{O}_K$ (un anillo más completo que contiene a $\mathbb{Z}[\alpha]$), aunque los elementos no puedan ser factorizados de manera única, se ha demostrado que “los ideales siempre pueden ser factorizados de forma única como un producto de ‘ideales primos ($\mathfrak{p}$)’”.

Por lo tanto, en GNFS, no descomponemos el elemento $(a - b\alpha)$ en sí, sino que hacemos la factorización en ideales primos del ideal principal $\langle a - b\alpha \rangle$ que este genera.

Etapa 3: Norma (Norm) y las dos Cribas (Sieves)

Entonces, ¿cómo sabemos en qué ideales primos se descompone el ideal $\langle a - b\alpha \rangle$? Aquí utilizamos una función llamada “Norma” (Norm). La norma es una función que convierte los elementos complejos de los cuerpos algebraicos en “números enteros reales ordinarios $\mathbb{Z}$”.

La norma del elemento $(a - b\alpha)$ se calcula mediante un simple cálculo polinomial $b^d f(a/b)$ (donde $d$ es el grado de $f(x)$).

Por teoremas algebraicos, sabemos que “si la norma de un ideal se descompone completamente en primos pequeños (es un número liso o ‘smooth’), entonces su ideal original también se descompone completamente en ideales primos pequeños”.

Por lo tanto, GNFS calcula simultáneamente lo siguiente para una gran cantidad de pares de enteros $(a, b)$, y recolecta solo los pares donde ambos son “números lisos”:

Criba Racional (Rational Sieve): $a - bm$ (valor en el mundo real)
Criba Algebraica (Algebraic Sieve): $b^d f(a/b)$ (norma en el mundo del cuerpo algebraico)

Recolecta decenas de millones de pares $(a, b)$ donde ambos son lisos, resuelve los datos de factorización prima de los ideales (cuántos ideales primos están incluidos) como una matriz gigante (álgebra lineal sobre GF(2)), y encuentra un conjunto de pares $S$ de manera que “cuando se multiplican, los exponentes de todos los ideales primos se vuelven pares”.

Etapa 4: Dos “Obstáculos” que se interponen y el Grupo de Clases de Ideales

Mediante cálculos de matrices, encontramos que multiplicar todos los ideales de $(a - b\alpha)$ que pertenecen al conjunto $S$ resulta en el cuadrado de cierto ideal $I$.

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

Sin embargo, esto aún no ha terminado. Aquí es donde se encuentra el muro matemático más profundo y difícil de GNFS.

Lo que finalmente queremos no es el “cuadrado de un ideal”, sino el “cuadrado de un elemento ($\gamma^2$)” para sustituirlo en el mapeo $\phi$. El hecho de que se haya convertido en el cuadrado de un ideal no significa que el elemento en sí sea un cuadrado. Aquí existen dos obstáculos matemáticos (Obstructions) formidables.

Obstáculo 1: El muro del Grupo de Clases de Ideales (Ideal Class Group)

El ideal $I$ no es necesariamente un “ideal generado por un solo elemento (ideal principal)”. Es imposible extraer un elemento concreto $\gamma$ de un ideal que no sea principal.

Aquí entra el concepto de “Grupo de Clases de Ideales” (Class Group, $Cl_K$). El grupo de clases de ideales es un grupo que mide “cuántos ideales que no son principales existen en ese mundo del cuerpo algebraico (qué tan destruida está la unicidad de la factorización prima)”. Incluso si $\prod \langle a - b\alpha \rangle$ se convierte en $I^2$, si $I$ no es el elemento identidad (ideal principal) en el grupo de clases de ideales, no podemos retroceder al cuadrado de un elemento.

Obstáculo 2: El muro del Grupo de Unidades (Unit Group)

Supongamos que por suerte $I$ era un ideal principal $\langle \gamma \rangle$. Entonces tenemos que $\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$. Podrías pensar “¡Genial, el elemento también es un cuadrado!”, pero estarías muy equivocado.

Que los ideales (conjuntos de múltiplos) sean iguales no significa que los elementos sean completamente iguales. Siempre ocurre una desviación por una “Unidad” (Unit: un número cuyo inverso multiplicativo también es entero. Por ejemplo, 1 o -1). Es decir, la verdadera igualdad de los elementos es la siguiente:

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

($u$ es un elemento del grupo de unidades $U_K$)

A menos que esta unidad $u$ sea en sí misma un cuadrado (elemento cuadrático) de algo, el lado izquierdo nunca podrá ser un “cuadrado perfecto de un elemento”.

Etapa 5: La magia de Adleman, “Caracteres Cuadráticos” (Quadratic Characters)

Los obstáculos del grupo de clases de ideales y del grupo de unidades. ¿Cómo los superamos? Aquí es donde entra la genial técnica introducida por el criptógrafo Leonard Adleman (la “A” de RSA) y otros: los “Caracteres Cuadráticos” (Quadratic Characters).

Para determinar “si un elemento es un cuadrado perfecto dentro de un cuerpo algebraico”, utilizamos una versión para cuerpos algebraicos del símbolo de Legendre (residuo cuadrático). En la matriz gigante anterior (el rompecabezas para hacer que el número de ideales primos sea par), añadimos en secreto unas cuantas decenas de condiciones (columnas) adicionales para que “los caracteres cuadráticos para algunos ideales primos especiales $\mathfrak{q}$ también sean todos $1$ (pares)”.

Cuando encontramos un conjunto $S$ que incluso satisface estas condiciones adicionales mediante el cálculo de matrices, por los teoremas profundos de la teoría de números algebraicos, se garantiza que “los obstáculos tanto del grupo de clases de ideales como del grupo de unidades desaparecerán naturalmente con una probabilidad abrumadora”.

Con esto, por fin obtenemos la verdadera ecuación.

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

Etapa Final: La fusión de los mundos y el colapso criptográfico

Por fin, todas las piezas del rompecabezas están en su lugar.

[Elementos del Mundo del Cuerpo Algebraico (Mundo A)] $\gamma^2 = \prod (a - b\alpha)$ (De aquí usamos un algoritmo de raíz cuadrada para encontrar $\gamma$)

[Elementos del Mundo Real (Mundo de los Números Racionales)] $V^2 = \prod (a - bm)$ (Como esta es una simple multiplicación de enteros, podemos encontrar la raíz cuadrada $V$ normalmente)

Ahora, es el turno del puente mágico que construimos al principio: el homomorfismo $\phi$. Transportamos el elemento $\gamma$ del Mundo A al Mundo B (el mundo de restos módulo $N$) usando $\phi$ (el mapeo que sustituye $\alpha$ por $m$).

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

Por otro lado, tomamos la $V$ que creamos en el mundo real directamente al mundo de los restos y la llamamos $X$.

$$X = V \pmod N$$

Debido a la propiedad de “conservar estructuras” del homomorfismo, la relación de los cuadrados que se sostenía en el Mundo A se preserva perfectamente en el Mundo B (el mundo módulo $N$). Además, dado que el par original $(a, b)$ fue creado correspondientemente en la forma $a - b\alpha$ y $a - bm$, estas $X$ e $Y$ chocan en el mundo módulo $N$ y producen la siguiente igualdad absoluta:

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

El resto es rezar para que $X$ e $Y$ no sean una solución trivial ($X \equiv \pm Y$), y calcular: $\gcd(X - Y, N)$

Si es una solución no trivial, el algoritmo de Euclides correrá en 0.001 segundos e imprimirá en la pantalla de salida el corazón del cifrado RSA: los primos secretos $p$ y $q$.

Esta es la forma completa de la “Criba General del Cuerpo de Números (GNFS)”, que reúne lo mejor de las matemáticas modernas.

¿Qué es la 'Criba General del Cuerpo de Números (GNFS)', la matemática más fuerte de la humanidad que rompe el cifrado de Internet?

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

¿Qué es la “Criba General del Cuerpo de Números (GNFS)”, las matemáticas más fuertes de la humanidad que rompen el cifrado de Internet?

El Internet que usamos todos los días. Los mensajes de LINE, YouTube, las compras en Amazon, todas las comunicaciones están protegidas por “cifrado”. Actualmente, el representante del cifrado más utilizado en todo el mundo es el “Cifrado RSA”.

La clave de la defensa del cifrado RSA es muy simple. Utiliza la propiedad matemática de que “la factorización de números primos gigantescos no puede ser resuelta ni siquiera por computadoras”. Por ejemplo, si es “15”, se sabe inmediatamente que es “3 × 5”, pero en el momento en que esto se convierte en un “número de 270 dígitos”, incluso reuniendo las supercomputadoras de todo el mundo llevaría cientos de millones de años resolverlo.

Sin embargo, los matemáticos tampoco se han quedado callados. Para romper este cifrado inexpugnable, la humanidad ha creado un algoritmo (procedimiento de cálculo) parecido a la magia llamado “Criba General del Cuerpo de Números (GNFS: General Number Field Sieve)”.

En este artículo, sin usar términos técnicos en absoluto, explicaremos paso a paso y de manera completa el truco por el cual este “algoritmo más fuerte de la humanidad” rompe el cifrado, solo con conocimientos de matemáticas de secundaria (factorización de primos, álgebra, máximo común divisor)!

Capítulo 1: El objetivo de descifrar el código es “la fórmula de tercer año de secundaria”

El mayor ataque especial para enfrentar la factorización de números primos gigantes. Es esta fórmula que se aprende en tercer año de secundaria.

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

Puede que pienses: “¿Eh, se puede romper un cifrado con una fórmula tan básica?”. Sin embargo, esta es precisamente la llave maestra que lo revela todo.

El objetivo principal para romper el cifrado es, para un número gigante $N$, encontrar “números ($X$ e $Y$) cuyo residuo al dividir $X^2$ e $Y^2$ por $N$ sea el mismo”.

¿Por qué se puede descifrar el código si “el residuo es el mismo”?

Supongamos que el “residuo al dividir por $N$” de dos números, $X^2$ e $Y^2$, es el mismo. Que el residuo sea el mismo significa que existe la regla de que la resta “$X^2 - Y^2$” siempre se divide exactamente por $N$ (es un múltiplo de $N$).

Aquí, supongamos que el número gigante $N$ usado en el cifrado está hecho por la multiplicación de dos números primos secretos ($p$ y $q$) ($N = p \times q$).

Al factorizar $X^2 - Y^2$, se convierte en $(X - Y)(X + Y)$. El hecho de que esto sea un múltiplo de $N$ significa que en algún lugar de esta multiplicación están escondidos los números primos secretos $p$ y $q$.

Aquí ocurre un milagro. La probabilidad de que los dos números primos $p$ y $q$ se separen en habitaciones diferentes, "$p$ va a la habitación de $(X - Y)$" y “$q$ va a la habitación de $(X + Y)$”, es matemáticamente del ** 50% (un medio)**.

Con solo el número primo $p$ entrando en la habitación de $(X - Y)$, calculemos el “máximo común divisor (la pieza común más grande)” de $(X - Y)$ y $N$.

Contenido de $(X - Y)$ = $p \times$ algún número
Contenido de $N$ = $p \times q$ ¡La única pieza común es "$p$"!

Es decir, en el momento en que se calcula el máximo común divisor, el número primo oculto $p$ cae, ¡y el cifrado se descifra por completo! (*El máximo común divisor se puede calcular en un instante incluso en un teléfono inteligente si usas el “Algoritmo de Euclides”).

[Breve columna: ¿Por qué al cuadrado? ¿No se puede al cubo o al doble?]

Si es “$2X - 2Y$”, se convierte en $2(X - Y)$ y como solo hay una habitación, no se pueden separar los números primos. Si es “$X^3 - Y^3$”, el tamaño de las habitaciones se desequilibra y el cálculo se vuelve innecesariamente pesado. Para separar los números primos en dos, la opción más eficiente que se divide bellamente en dos habitaciones es “al cuadrado”.

Capítulo 2: ¿Cómo buscar X e Y? “El rompecabezas de recolectar tarjetas de números primos”

Ya sabemos el objetivo. Sin embargo, incluso si buscas al azar “$X^2$ e $Y^2$ que tengan el mismo residuo”, no lo encontrarás hasta que se acabe la vida útil del universo. Por eso, los matemáticos idearon un método genial llamado “el rompecabezas de recolectar tarjetas de números primos”.

Paso 1: Recolectar solo el oro en polvo (números suaves) con un tamiz

Primero, preparamos un número adecuado $Z$, lo elevamos al cuadrado y calculamos el residuo $W$ al dividirlo por $N$. (El mundo del residuo de $Z^2 = W$)

Factorizamos el residuo $W$ resultante. Aquí, solo cuando aparece un "$W$ compuesto solo de números primos pequeños como 2, 3, 5, 7, etc.", guardamos esa fórmula como una “tarjeta ganadora”, y si se mezclan números primos grandes, la tiramos. Es como la tarea de tirar piedras grandes con un tamiz en un río y recolectar solo el polvo de oro.

Paso 2: El rompecabezas de hacer todo “número par”

Por ejemplo, supongamos que se reunieron las siguientes tres tarjetas de polvo de oro:

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

Multipliquemos todo esto. El lado derecho se convierte en $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$, y al organizarlo todo junto queda "$2^4 \times 3^2 \times 5^2$".

¡Increíblemente, la cantidad de números primos se ha vuelto “4, 2, 2”, todos en cantidades pares! El hecho de que todos sean cantidades pares significa que si reducimos la cantidad total a la mitad, se convierte en el “cuadrado de algo”. Es decir, $(2^2 \times 3^1 \times 5^1)^2 = (60)^2$.

Dado que el lado izquierdo es $(Z_1 \times Z_2 \times Z_3)^2$, ¡con esto finalmente se completa el tan esperado par de “$X^2 = Y^2$” que es $X = (Z_1 \times Z_2 \times Z_3)$ $Y = 60$!

Dado que a las computadoras se les da muy bien el rompecabezas de calcular si la cantidad de números primos es “par o impar (0 o 1)”, con este método pueden encontrar $X$ e $Y$ a alta velocidad.

Capítulo 3: El muro de la desesperación que se interpone

¡Con esto se puede romper cualquier cifrado!… Eso pensarías, pero surge un gran problema. Si el número $N$ del cifrado tiene hasta “100 dígitos”, se puede resolver con este método (llamado criba cuadrática), pero cuando $N$ se convierte en “200 dígitos, 300 dígitos”, el $W$ que aparece en el medio del cálculo se vuelve demasiado grande.

Cuando los números se vuelven demasiado grandes, de repente dejan de aparecer los “números hechos solo de primos pequeños (polvo de oro)”. Se vuelve más difícil que buscar una lente de contacto en el desierto, y ya no se pueden juntar en absoluto las tarjetas para resolver el rompecabezas.

Aquí finalmente aparece el arma definitiva de la humanidad, la “Criba General del Cuerpo de Números (GNFS)”.

Capítulo 4: La idea más fuerte de la humanidad: Crear “dos mundos”

La idea genial de GNFS es: “Como calculamos solo en el mundo real, los números se vuelven enormes. Entonces, hagamos un ‘mundo oculto’ usando polinomios (expresiones algebraicas) y dividamos el peso del cálculo en dos”.

La magia de las expresiones algebraicas

GNFS convierte un número gigante $N$ en una expresión algebraica usando un número base $m$. Por ejemplo, si $N=100$, usando $m=4$, $100 = 4^3 + 2(4^2) + 4$. Usando la letra $x$, convertimos esto en la expresión (el mundo oculto) $f(x) = x^3 + 2x^2 + x$.

Lo interesante de esta expresión es que tiene la propiedad de que “si sustituyes la letra $x$ por $m$ (4 en el ejemplo anterior), siempre puedes regresar (teletransportarte) al número real $N$”.

Buscar oro en polvo en dos mundos al mismo tiempo

GNFS crea muchos pares de números enteros $(a, b)$ y realiza los siguientes dos cálculos al mismo tiempo:

El mundo real: $a - b \times m$
El mundo algebraico: el valor de calcular $a - b \times x$ con las reglas del álgebra

Al dividir el problema en dos mundos, el tamaño de los números manejados se vuelve drásticamente menor (más ligero). Es la imagen de partir una roca gigante en dos para convertirla en piedras fáciles de manejar.

Luego, con un tamiz (criba), se recolectan solo los pares milagrosos $(a, b)$ que son “tanto en el mundo real como en el mundo algebraico, ‘hechos solo de números primos pequeños (polvo de oro)’”. Este es el origen del nombre “Criba del Cuerpo de Números”.

El momento en que finalmente se rompe el cifrado

Cuando se reúnen decenas de millones de “tarjetas de polvo de oro” de ambos mundos, utilizando los cálculos de matrices gigantes de una supercomputadora, descubrimos las “combinaciones donde la cantidad de números primos se vuelve toda par” que hicimos en el Capítulo 2.

Una vez que se encuentra la combinación,

Sea el número al cuadrado creado en el mundo real $X^2$
Sea la expresión al cuadrado creada en el mundo algebraico $Y(x)^2$

Finalmente, sustituimos $x$ en el $Y(x)$ del mundo algebraico por $m$, para teletransportarlo y unirlo al mundo real. Entonces, como magia matemática, se completa estrictamente el estado en que “el residuo de $X^2$ y $Y^2$ es el mismo”!

El resto es como en el Capítulo 1, si calculamos el máximo común divisor de $X - Y$ y $N$, el inexpugnable cifrado RSA colapsa estruendosamente, y los números primos secretos hacen su aparición.

Conclusión: Las matemáticas no terminan

Es posible que hayas pensado: “¡Genial, con GNFS se puede romper cualquier cifrado!”. Sin embargo, el cifrado RSA tampoco se queda atrás. Lo que se utiliza en el Internet actual es un número gigantesco monstruoso llamado “RSA-2048 (unos 617 dígitos)”.

Aunque GNFS es el algoritmo más fuerte de la humanidad, se dice que incluso para resolver 270 dígitos (RSA-270), llevaría miles o decenas de miles de años incluso conectando las computadoras de todo el mundo. Por ahora, nuestros datos de LINE o bancos están a salvo.

Sin embargo, ¿qué pasaría si apareciera “una magia para encontrar $X$ e $Y$ en un instante sin importar cuán grande sea el número”? En realidad, la existencia más cercana a eso es la “computadora cuántica (Algoritmo de Shor)” actualmente en desarrollo. Usando las propiedades ondulatorias de la mecánica cuántica, se ha demostrado matemáticamente que se puede ignorar el molesto rompecabezas de recolección de tarjetas y encontrar la respuesta en un solo intento.

La interminable batalla de ingenio entre los creadores de cifrados (defensa) y los creadores de algoritmos para romperlos (ataque). Saber que la “factorización de primos” o el “álgebra” que se aprenden en la secundaria son en realidad armas que luchan ferozmente en la vanguardia de la seguridad mundial, ¿no hace que las clases de matemáticas parezcan un poco más interesantes?

¡Podrías ser tú, que estás leyendo este artículo, quien descubra el algoritmo más fuerte del futuro!

(※Este artículo conceptualiza el encanto matemático del criptoanálisis para estudiantes de secundaria. El GNFS real se calcula estrictamente usando matemáticas universitarias avanzadas, como el grupo de clases de ideales de cuerpos algebraicos y homomorfismos)

[Consideración matemática] ¿Por qué el algoritmo de descifrado 'GNFS' es derrotado por el algoritmo de Shor en la era cuántica?

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

La seguridad de la información en la sociedad de Internet moderna está protegida por sistemas de criptografía de clave pública como la criptografía RSA. La base de la seguridad del cifrado RSA depende del hecho de que “la factorización de números compuestos enormes es computacionalmente muy difícil”.

En este artículo, desentrañaremos el mecanismo matemático de la “Criba General del Cuerpo de Números” (General Number Field Sieve, GNFS), que es el algoritmo de factorización más fuerte en computadoras clásicas, y profundizaremos a través de fórmulas y diagramas conceptuales por qué es completamente derrotado por el “Algoritmo de Shor” descubierto por Peter Shor, y el cambio de paradigma que esto representa.

1. El enfoque de la factorización en la computación clásica: Desarrollo a partir del método de factorización de Fermat

El problema de factorización prima es encontrar los números primos $p, q$ tales que $N = p \times q$ para un número compuesto $N$ dado.

La idea básica se reduce a encontrar valores no triviales $x, y$ que satisfagan la siguiente congruencia:

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

Transformando esto,

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

Aquí, si $x \not\equiv \pm y \pmod N$, al calcular $\gcd(x-y, N)$ o $\gcd(x+y, N)$, podemos obtener un factor no trivial de $N$. Este hecho es la base de los algoritmos de factorización modernos como GNFS.

2. El algoritmo clásico más fuerte: Las profundidades de la “Criba General del Cuerpo de Números” (GNFS)

“GNFS” es el algoritmo de factorización más rápido conocido en la actualidad para computadoras clásicas. Su complejidad temporal requiere un tiempo subexponencial.

Complejidad del GNFS

Si el número de dígitos de $N$ es $b = \log_2 N$, la complejidad del GNFS se expresa de la siguiente manera:

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

Como se puede ver en esta fórmula, el tiempo de cálculo no es polinomial, sino “tiempo subexponencial”, que es ligeramente más lento que el exponencial. Aun así, si el número de dígitos aumenta, el tiempo de cálculo aumenta astronómicamente.

Mecanismo matemático de GNFS

GNFS consta principalmente de 4 pasos:

Selección de polinomios (Polynomial Selection)
Criba (Sieving)
Reducción de matrices (Matrix Reduction)
Cálculo de raíz cuadrada (Square Root)

2.1. Selección de polinomios y cuerpos de números

Primero, seleccionamos polinomios irreducibles $f(x)$ y $g(x)$ con coeficientes enteros. Estos se configuran para tener una raíz común $m$ módulo $N$. Es decir,

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

Normalmente, $g(x)$ se elige como un polinomio de primer grado $g(x) = x - m$. Si hacemos que la raíz de $f(x)$ sea $\alpha$, construimos un “cuerpo de números” (Number Field) llamado $\mathbb{Q}(\alpha)$. Comparamos las operaciones en el anillo de $\mathbb{Q}(\alpha)$ y las operaciones en el anillo de enteros habitual $\mathbb{Z}$ a través del homomorfismo $\phi: \alpha \mapsto m$.

2.2. Criba (Sieving)

A continuación, buscamos una gran cantidad de pares de enteros coprimos $(a, b)$. El objetivo es encontrar pares tales que los dos valores siguientes sean “B-smooth” (compuestos solo por factores primos relativamente pequeños):

$a - bm$ (valor en el anillo de enteros)
$b^d f(a/b)$ (correspondiente a la norma $N(a - b\alpha)$ sobre el cuerpo de números)

Aquí se utiliza una técnica de búsqueda rápida llamada “criba” (Sieve). Esto extrae eficientemente pares $(a, b)$ que cumplen las condiciones de entre una enorme cantidad de candidatos.

2.3. Reducción de matrices (Linear Algebra over GF(2))

A partir de los pares recolectados $(a, b)$, formamos vectores de exponentes y encontramos el espacio nulo izquierdo de una enorme matriz dispersa sobre $\mathbb{F}_2$ (un cuerpo cuyos elementos son solo 0 y 1).

Encontramos el vector $v$ como solución para que las relaciones $ \prod (a_i - b_i m) $ y $ \prod (a_i - b_i \alpha) $ se conviertan ambas en elementos cuadrados. Esto no es más que resolver el sistema de ecuaciones lineales:

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

Aquí se aprovechan algoritmos numéricos avanzados como el algoritmo de Block Lanczos o el algoritmo de Block Wiedemann.

2.4. Cálculo de raíz cuadrada

Finalmente, extraemos raíces cuadradas tanto en el cuerpo de números como en el anillo de enteros para derivar la relación $x^2 \equiv y^2 \pmod N$. Luego, calculamos $\gcd(x-y, N)$ para obtener los factores.

3. El avance mediante computación cuántica: “Algoritmo de Shor”

Mientras que el GNFS requiere tiempo subexponencial, el “Algoritmo de Shor” introducido por Peter Shor en 1994 puede resolver este problema en “tiempo polinomial” utilizando una computadora cuántica.

Complejidad del Algoritmo de Shor

Cuando el número de qubits es $O(\log N)$, la complejidad temporal es:

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

Esto significa que no causa una explosión exponencial con respecto al número de bits. Es un resultado sorprendente donde números compuestos enormes que excederían la vida útil del universo con “computación clásica”, pueden ser descifrados en unas pocas horas o días con “computación cuántica”.

Visión general del Algoritmo de Shor: Reducción al problema de búsqueda de períodos

El algoritmo de Shor reduce ingeniosamente el problema de factorización prima a un “problema de búsqueda de períodos”.

Elegir un entero aleatorio $a$ coprimo con $N$ ($1 < a < N$).
Definir la función $f(x) = a^x \bmod N$.
Encontrar el período $r$ de $f(x)$, es decir, el entero positivo mínimo $r$ tal que $a^r \equiv 1 \pmod N$.
Si $r$ es par, verificar si $a^{r/2} \not\equiv -1 \pmod N$ y calcular $\gcd(a^{r/2} \pm 1, N)$ para obtener los factores primos.

Esta “búsqueda del período $r$” en el paso 3 es el cuello de botella que requiere un tiempo exponencial en las computadoras clásicas, pero las computadoras cuánticas lo resuelven en un instante utilizando “superposición cuántica” y la “Transformada de Fourier Cuántica” (QFT).

4. Transformada de Fourier Cuántica (QFT) y Extracción de Períodos

Veamos en detalle a través de fórmulas la manipulación de estados cuánticos, que es el núcleo del algoritmo de Shor.

4.1. Generación de superposición cuántica

Primero, preparamos dos registros cuánticos. El registro 1 almacena el estado de superposición de la entrada $x$, y el registro 2 almacena el resultado de la función $f(x)$. Aplicamos la Transformada de Hadamard al estado inicial $|0\rangle |0\rangle$ para crear una superposición de todos los $x$ posibles.

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

(donde $Q$ es una potencia de 2 que satisface $N^2 \le Q < 2N^2$)

A continuación, utilizamos el oráculo cuántico $U_f$ para calcular $f(x) = a^x \bmod N$ y almacenarlo en el registro 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 $$

Supongamos que medimos el registro 2 aquí (en realidad, la estructura matemática es la misma incluso sin medir). Si se observa un cierto valor $y = a^{x_0} \bmod N$, el estado del registro 1 colapsa a una superposición de todos los $x$ tales que $f(x) = y$. Si el período es $r$, tales $x$ serán $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 $$

(donde $M \approx Q/r$ es el número de términos)

Este estado contiene información sobre el período $r$, pero la medición directa solo arrojaría un $x_0 + kr$ aleatorio, por lo que el período $r$ sigue siendo desconocido. Aquí es donde entra en juego la QFT.

4.2. Aplicación de la Transformada de Fourier Cuántica

La QFT es una operación que realiza una transformada de Fourier discreta sobre las amplitudes de los estados cuánticos. La acción de la QFT sobre el estado $|x\rangle$ se define de la siguiente manera:

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

Al aplicar esto a $|\psi_3\rangle$, ocurre una interferencia de fase (interferencia cuá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 $$

Expandiendo la suma en esta fórmula,

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

Aparece esta parte. La suma de esta serie geométrica se refuerza constructivamente solo cuando $ry/Q$ está cerca de un entero (Interferencia constructiva), y de lo contrario se cancela mutuamente (Interferencia destructiva).

Por lo tanto, el estado $|y\rangle$ medido con alta probabilidad es un entero $y$ que satisface la condición:

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

(donde $c$ es algún entero).

4.3. Identificación de períodos mediante expansión en fracciones continuas

Después de obtener $y$ mediante medición, usamos una computadora clásica para realizar la “expansión en fracciones continuas” (Continued Fraction Expansion) de $y/Q$. Esto nos permite calcular la fracción aproximada $c/r$ de $y/Q$ y extraer eficientemente los candidatos para el período $r$ a partir del denominador.

5. Comparación de modelos conceptuales y el cambio de paradigma

Para entender intuitivamente la diferencia entre GNFS y el algoritmo de Shor, mostramos un diagrama conceptual utilizando sintaxis Mermaid.

Diagrama conceptual del algoritmo de Shor mediante circuito cuántico

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


graph TD
 A[Estado inicial: 0...0] --> B[Superposición de todos los estados por Transformada de Hadamard]
 B --> C[Operación de exponenciación modular a^x mod N]
 C -->|Entrelazamiento cuántico| D[Colapso a un estado con periodicidad]
 D --> E[Transformada de Fourier Cuántica QFT]
 E -->|Amplificación de probabilidad por interferencia| F[Medición: Obtener y]
 F --> G[Procesamiento clásico: Expansión en fracciones continuas]
 G --> H[Búsqueda del período r]
 H --> I[Cálculo de factores 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

La esencia del cambio de paradigma

El GNFS adopta el enfoque de “buscar relaciones dentro de un espacio matemático (cuerpo de números)”. Sin embargo, debido a que el espacio de búsqueda se expande exponencialmente con el número de dígitos, la capacidad de cálculo de las computadoras clásicas (incluso con paralelización) hace que sea virtualmente imposible de descifrar cuando la longitud de la clave supera los 2048 bits, etc.

Por otro lado, el algoritmo de Shor utiliza “las propiedades ondulatorias debidas a la interferencia cuántica”. Evalúa simultáneamente todas las rutas de cálculo en estado de superposición y cancela (interferencia destructiva) las respuestas innecesarias mediante la QFT, amplificando (interferencia constructiva) solo la amplitud de probabilidad del período que es la respuesta correcta. Con esto, logra un enfoque en una dimensión completamente diferente que, en lugar de buscar en el espacio, “hace que la respuesta correcta misma emerja”.

6. Conclusión

En este artículo, comparamos profundamente los antecedentes matemáticos y las estructuras de los algoritmos de “GNFS”, que es el pináculo del límite clásico, y el “Algoritmo de Shor”, que muestra el poder de la computación cuántica.

Mientras que el GNFS redujo la complejidad temporal al tiempo subexponencial mediante elaboradas técnicas matemáticas como la selección de polinomios y el cálculo de enormes matrices, el algoritmo de Shor fusionó la superposición y la interferencia, que son los principios básicos de la mecánica cuántica, con herramientas matemáticas (QFT) para lograr un avance hacia el tiempo polinomial de un solo golpe.

Actualmente, no existe una computadora cuántica tolerante a fallas (FTQC) que pueda ejecutar el algoritmo de Shor a una escala práctica (miles de qubits). Sin embargo, la existencia misma de este cambio de paradigma matemático y teórico es la mayor razón por la que en todo el mundo se está acelerando la transición a la criptografía poscuántica (PQC: Post-Quantum Cryptography).