Matemáticas 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)

La conjetura de Kepler explicada de forma sencilla

Mon, 21 Jul 2025 22:53:03 +0900

¡La conjetura de Kepler explicada de forma sencilla! 〜La mejor forma de empaquetar sandías〜

¡Hola, soy kenji!

Hoy me gustaría explicar de la forma más sencilla posible una historia matemática con un nombre que suena un poco difícil: “La conjetura de Kepler”.

A primera vista, parece un tema muy específico para aficionados, pero también es un problema bastante cotidiano: “¿Cómo podemos empaquetar sandías en una caja de la manera más compacta posible?”. Tiene que ver con las neveras de las tiendas de conveniencia y también con cómo se apila la carga.

Y, en el mundo de las matemáticas, esta es una historia súper romántica porque ¡no se pudo demostrar durante más de 400 años!.

¡Vamos a ello!

Para empezar, ¿quién es Kepler?

Primero, ¿quién es el “Kepler” de la “conjetura de Kepler”?

Es el nombre de Johannes Kepler, un astrónomo y matemático alemán.

Este hombre fue increíble. Por ejemplo, fue él quien descubrió que las órbitas de los planetas son elípticas. Hoy en día es un conocimiento básico, pero en aquella época (alrededor del año 1600) era una época en la que ni siquiera se creía firmemente en el heliocentrismo.

Galileo = Genio de la observación
Kepler = Genio que explicó el universo con fórmulas matemáticas
Newton = Súper genio que resumió esa teoría en leyes físicas

En ese sentido, Kepler fue un pionero en “explicar el universo con fórmulas matemáticas”.

Y así, un día, él planteó lo siguiente.

¿Qué es la conjetura de Kepler?

La “conjetura de Kepler”, en pocas palabras, es esto:

Cuando empaquetas esferas del mismo tamaño (sandías o naranjas) en una caja, ¿qué disposición permite empaquetarlas de la manera más compacta?

Ese es el problema.

Y lo que Kepler conjeturó en la década de 1600 fue:

Igual que cuando se apilan las naranjas en la frutería, apilarlas en forma de triángulo, ¿no es lo más eficiente?

A esto se le llama en matemáticas el “problema del empaquetamiento de esferas”, que busca la forma de empaquetar esferas de la manera más densa en el espacio.

Kepler predijo que una disposición llamada “estructura cúbica centrada en las caras (FCC)” (algo así como apilar sandías en forma de triángulo) era la más eficiente.

Y, bueno, todos pensaban “sí, parece que es así”, pero demostrar matemáticamente que “¡definitivamente es la mejor!” era extremadamente difícil.

¡¿400 años hasta la demostración?!

Entonces, ¿cuándo se demostró realmente?

Increíblemente, fue alrededor de 1998 a 2005. Es decir, nadie pudo demostrarlo en casi 400 años. Una locura.

Además, quien lo demostró fue el matemático estadounidense Thomas Hales.

Él dedujo que era imposible hacerlo solo a mano y utilizó computadoras para la demostración. Sin embargo, surgió un problema: ¡la demostración era tan compleja que los humanos no podían verificarla correctamente!

Por eso, en el mundo de las matemáticas, se desató un gran debate: “Entonces, ¿podemos confiar realmente en algo demostrado con una computadora?”.

Finalmente, la demostración (oficialmente llamada “demostración formal”) de que “¡ha sido verificado estrictamente incluyendo la computadora!” se completó en 2014.

En otras palabras, pasaron más de 400 años hasta que se demostró que la intuición de Kepler era correcta. Qué romántico.

También se utiliza mucho en la vida real

Uno pensaría que “cómo apilar esferas” es algo que solo interesa a los frikis de las matemáticas, pero en realidad es súper práctico.

Para empacar eficientemente las bebidas en las neveras de las tiendas de conveniencia
Al apilar latas en palés de transporte
También se aplica en las comunicaciones (como en la compresión de señales digitales)
Se usa en impresoras 3D y en el diseño de estructuras cristalinas

Y muchas más, de hecho es una teoría que se usa muchísimo detrás de nuestra vida cotidiana.

Conclusión: La intuición humana es asombrosa

En fin, para resumir:

Conjetura de Kepler = ¿Cómo empaquetar esferas de la manera más compacta?
Kepler = Matemático y astrónomo que descubrió la órbita de los planetas
¡Se conjeturó en el siglo XVII! ¡Pero se demostró en el siglo XXI!
¡Tiene muchas aplicaciones en la vida real!

Y lo más interesante de todo es: “La forma de apilar que los fruteros hacían por intuición, también era la mejor matemáticamente.”

En otras palabras, la intuición humana es asombrosa. Y que puede tomar 400 años demostrarlo, es una historia verdaderamente romántica.

Si te interesa, busca sobre “Thomas Hales”, “demostración formal” o “Sphere Packing”. Si profundizas en el tema, es súper interesante.

¡Hasta luego!

[PR]

Comprar ahora

La conjetura de Collatz

Tue, 15 Jul 2025 18:03:03 +0900

¿Es cierto que “cualquier número termina en 1”? ── Jugando con la Conjetura de Collatz

¡Hola! Soy kenji.

De repente, si escuchas sobre “una regla donde cualquier número termina finalmente en 1”, ¿no te parece un poco extraño?

Por ejemplo, el 19, el 87 o incluso el 1000000. Si sigues una regla simple y manipulas el número, por alguna razón siempre converge a “1” al final.

Esta historia que parece un sueño es la Conjetura de Collatz (Collatz Conjecture).

Para empezar, ¿qué es la Conjetura de Collatz?

Primero, presentaré la regla.

Inicio: Elige cualquier entero positivo
Operación:
- Si es par → divídelo a la mitad (n → n / 2)
- Si es impar → multiplícalo por 3 y suma 1 (n → 3n + 1)

Si repites esto una y otra vez, la conjetura es que cualquier número finalmente llegará a 1.

Por ejemplo, si empezamos con el 6:

1

6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1

Efectivamente llegó a “1”. ¡Bienvenido de vuelta!

Hagámoslo con código: Collatz en Python

Bueno, en estos casos ¡es más rápido probar con código! Imprimamos la “secuencia de Collatz” en Python.

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


def collatz(n):
 steps = [n]
 while n != 1:
 if n % 2 == 0:
 n = n // 2
 else:
 n = 3 * n + 1
 steps.append(n)
 return steps

# Ejemplo: empezando con 19
print(collatz(19))

Al ejecutarlo:

1

[19, 58, 29, 88, 44, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]

Llega perfectamente al 1. Da bastantes rodeos, pero al final ¡alcanza la meta!

Por cierto, incluso si empiezas con 29, también llegará a 1 de la misma manera.

1

pythonprint(collatz(29))

Al ejecutarlo:

1
2
3
4
5
6
7
8


[27, 82, 41, 124, 62, 31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242,
121, 364, 182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350,
175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167,
502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479,
1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911,
2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732,
866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35,
106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1]

¡Vaya, toma 111 pasos!

Y además, hay momentos en los que se infla por encima de 9000. Es un patrón que da muchísimas vueltas antes de llegar a la meta.

Y, al final, ¿qué tiene de increíble?

Lo increíble de esta conjetura es,

Aunque no está comprobada, parece que funciona con cualquier número y termina en 1

Es justo eso.

¿Eh? Entonces, ¿qué pasa con 1 billón, o 1 trillón…?

Si pensaste eso, eres muy perspicaz. De hecho, usando computadoras se ha verificado hasta aproximadamente “2 elevado a 68”, y todos llegan a 1. Increíble…

Pero, no se ha demostrado teóricamente que “todos lo hagan”. Esto es lo que en el mundo de las matemáticas se llama un “problema no resuelto”.

¿Quién es el Sr. Collatz?

Y, al leer hasta aquí, seguro piensas “¿y quién es Collatz?”. ¡Lo presentaré adecuadamente!

Nombre: Lothar Collatz
Nacionalidad: Alemán
Nacimiento: 1910 - 1990
Profesión: Matemático (destacado en análisis funcional y teoría de números)

Propuso esta conjetura en 1937, y después de eso, durante más de 80 años nadie ha podido demostrarla ni refutarla.

Por cierto, este problema es tan simple pero tan profundo, que incluso el famoso Paul Erdős (un matemático súper famoso) dijo:

“Las matemáticas aún no están listas para la conjetura de Collatz”

En otras palabras, la teoría es que las matemáticas de la humanidad aún no han alcanzado este misterio…

No se necesitan “fórmulas matemáticas difíciles”

Lo bueno de la conjetura de Collatz es que cualquiera puede jugar.

Puedes hacerlo si tienes papel y bolígrafo. Si escribes el código en Python, puedes probarlo automáticamente. Y aun así, los matemáticos más avanzados lo están intentando en serio.

No sé, ¿no te emociona?

Bonus: Código para probar de una vez

También dejaré un código para probar varios números a la vez.

1
2
3


for n in range(1, 21):
 steps = collatz(n)
 print(f"{n}: {steps} (pasos: {len(steps)-1})")

Esto imprimirá la secuencia de Collatz del “1 al 20” de una vez.

Conclusión: Este mundo, al final, es misterioso

Así que, la conjetura de Collatz.

Aunque es súper simple
Nadie puede probarlo
Es un gran problema en el mundo de las matemáticas

Es como una masa de misterio.

¡Incluso los principiantes en programación pueden probarlo, así que anímate a jugar!

Enlaces recomendados (para interesados)

Wikipedia: Conjetura de Collatz
Artículo de Terence Tao (en inglés)
¡También es divertido crear una versión visual en Python! (Lo haré si hay peticiones)

Si quieres conocer más de este tipo de temas “Matemáticas misteriosas × Programación”, no dudes en pedirme “cuéntame más”. ¡Pronto te presentaré la Hipótesis de Riemann, historias sobre números primos y muchas cosas más!

📮 ¡Fin!

Conjetura P≠NP

Wed, 11 Sep 2024 02:22:39 +0900

Resumen

1

La clase P es la clase de problemas que pueden ser resueltos en tiempo polinómico por una máquina de Turing determinista, y la clase NP es la clase de problemas para los cuales, cuando se da una prueba de que la respuesta es afirmativa (llamada testigo), la validez del testigo puede ser verificada en tiempo polinómico (esto se llama verificación). Dado que los problemas que se pueden resolver en tiempo polinómico también se pueden verificar en tiempo polinómico, es evidente que P⊆NP, pero no está claro si P es un subconjunto propio de NP o no. Aunque todavía no hay pruebas, muchos investigadores creen que P≠NP. La conjetura de que la clase P y la clase NP no son iguales se llama "Conjetura P≠NP".

Sitio de referencia : https://daigakudenki.com/np-hard/

Código en C para generar números primos

Sat, 24 Aug 2024 09:38:10 +0900

A continuación, se muestra un código en C simple que genera números primos dentro de un rango especificado. En este ejemplo, se enumeran los números primos del 1 al n.

 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


#include <stdio.h>
#include <stdbool.h>

bool isPrime(int num) {
 if (num <= 1) return false;
 if (num <= 3) return true;
 if (num % 2 == 0 || num % 3 == 0) return false;

 for (int i = 5; i * i <= num; i += 6) {
 if (num % i == 0 || num % (i + 2) == 0) return false;
 }
 return true;
}

void printPrimes(int n) {
 printf("2 ");
 for (int i = 3; i <= n; i += 2) {
 if (isPrime(i)) {
 printf("%d ", i);
 }
 }
 printf("\n");
}

int main() {
 int n;
 printf("Ingrese el valor maximo del rango para generar numeros primos: ");
 scanf("%d", &n);
 printf("Los numeros primos de 1 a %d son los siguientes:\n", n);
 printPrimes(n);
 return 0;
}

Este código funciona de la siguiente manera:

Función isPrime: Determina si un número dado es primo. Por razones de eficiencia, primero verifica si es divisible por 2 y 3, y luego procede a verificar en múltiplos de 6.
Función printPrimes: Imprime los números primos dentro del rango especificado. El 2 se imprime primero, y luego solo se verifican los números impares.
Función main: Pide al usuario que ingrese el valor máximo del rango y luego imprime los números primos dentro de ese rango.

Al compilar y ejecutar este código, se mostrarán los números primos dentro del rango especificado.

Introducción a Mathematica

Thu, 25 Jul 2024 01:36:19 +0900

Introducción a Mathematica

Resolver ecuaciones

1

Solve[x^2 - 3 x + 2 == 0, x]

Salida

1

{{x -> 1}, {x -> 2}}

Encontrar soluciones enteras para una ecuación

1

Solve[x^2 - 3 x + 2 == 0 && 0 <= x <= 2, x, Integers]

Salida

1

{{x -> 1}, {x -> 2}}

Resolver un sistema de ecuaciones

1

Solve[{x + y == 3, x - y == 1}, {x, y}]

Salida

1

{{x -> 2, y -> 1}}

Resolver inecuaciones

1

Reduce[x^2 - 3 x + 2 > 0, x]

Salida

1

x < 1 || x > 2

Derivar

1

D[x^2, x]

Salida

1

2 x

Integrar

1

Integrate[x^2, x]

Salida

1

x^3/3

Calcular el límite

1

Limit[1/x, x -> 0]

Salida

1

Infinity

Calcular una serie

1

Sum[1/n^2, {n, 1, Infinity}]

Salida

1

π^2/6

Crear una matriz

1

m = {{1, 2}, {3, 4}}

Multiplicar matrices

1

m . m

Salida

1

{{7, 10}, {15, 22}}

Calcular la matriz inversa

1

Inverse[m]

Salida

1

{{-2, 1}, {1.5, -0.5}}

Calcular valores propios y vectores propios

1

Eigensystem[m]

Salida

1

{{5, 0}, {{1, 1}, {1, -1}}}

Calcular el producto punto de vectores

1

{1, 2} . {3, 4}

Salida

1

11

Calcular el producto cruzado de vectores

1

Cross[{1, 2, 3}, {4, 5, 6}]

Salida

1

{-3, 6, -3}

Calcular la magnitud (norma) de un vector

1

Norm[{1, 2, 3}]

Salida

1

√14

Calcular el ángulo entre vectores

1

ArcCos[{1, 2} . {3, 4}/(Norm[{1, 2}] Norm[{3, 4}])]

Salida

1

ArcCos[11/(√5 √25)]

Calcular la proyección de un vector

1

{1, 2} . {3, 4}/Norm[{3, 4}] {3, 4}/Norm[{3, 4}]

Salida

1

{11/5, 22/5}

Calcular la rotación de un vector

1

RotationMatrix[π/2].{1, 0}

Salida

1

{0, 1}

Calcular la traslación de un vector

1

TranslationTransform[{1, 2}][{3, 4}]

Salida

1

{4, 6}

Calcular la escala de un vector

1

ScalingTransform[{2, 3}][{1, 1}]

Salida

1

{2, 3}

Calcular la reflexión de un vector

1

ReflectionTransform[{1, 1}][{1, 1}]

Salida

1

{0, 0}

Generar un número aleatorio

1

RandomReal[]

Salida

1

0.123456

Generar un número aleatorio (entero)

1

RandomInteger[]

Salida

1

123456

Generar un número aleatorio (rango específico)

1

RandomReal[{1, 10}]

Salida

1

5.6789

Generar un número aleatorio (entero, rango específico)

1

RandomInteger[{1, 10}]

Salida

1

5

Generar un número aleatorio (distribución específica)

1

RandomVariate[NormalDistribution[0, 1]]

Salida

1

0.123456

Generar números aleatorios (distribución y cantidad específicas)

1

RandomVariate[NormalDistribution[0, 1], 10]

Salida

1

{0.123456, 0.234567, ..., 0.987654}

Generar números aleatorios (distribución, cantidad y semilla específicas)

1
2


SeedRandom[12345]
RandomVariate[NormalDistribution[0, 1], 10]

Salida

1

{0.123456, 0.234567, ..., 0.987654}

Aplicar una función a los elementos de un array

1
2
3


Map[Sqrt, {1, 4, 9}]
Sqrt /@ {1, 4, 9}
Map[#^(1/2)&, {1, 4, 9}]

Salida

1

{1, 2, 3}

Definir una función usando una expresión lambda

1
2


f = Function[x, x^2]
f[3]

Salida

1

9

Componer funciones

1
2
3
4


f = Function[x, x^2]
g = Function[x, x + 1]
h = Function[x, f[g[x]]]
h[3]

Salida

1

16

Hacer referencia al resultado del cálculo anterior

1

% + 1

Salida

1

17

Función pura

1

(#+3)&[5]

Salida

1

8

Extraer elementos de un array

1
2


Select[{1, 2, 3, 4, 5}, EvenQ]
Select[{1, 2, 3, 4, 5}, Mod[#,2]==0&]

Salida

1

{2, 4}

'¿Qué es la paradoja del cumpleaños?'

Tue, 02 Apr 2024 01:20:50 +0900

¿Conoces la paradoja del cumpleaños?

Voy a contarte algo un poco curioso. ¿Cuántas personas crees que tienen que reunirse para que la probabilidad de que “haya personas con el mismo cumpleaños” sea alta?

Por ejemplo, como un año tiene 365 días, si te dicen que “si se reúnen 23 personas, la probabilidad de que alguien comparta cumpleaños es de más del 50%”… de alguna manera parece ir en contra de la intuición, ¿verdad?

Pero esto, realmente es más del 50%.

¿Por qué ocurre esto?

Este fenómeno se llama la “paradoja del cumpleaños”. El nombre incluye “paradoja”, pero tiene una razón matemática sólida.

Si el número de personas es “n”, la probabilidad de que nadie comparta cumpleaños se puede calcular con la siguiente fórmula:

1

P(nadie comparte) = 365/365 × 364/365 × 363/365 × ... × (365 - n + 1)/365

Al restar esto de 1, se obtiene “la probabilidad de que alguien comparta cumpleaños”.

Al mirar los resultados…

Número de personas	Probabilidad de que haya personas con el mismo cumpleaños
10 personas	Aprox. 11.7%
20 personas	Aprox. 41.1%
23 personas	Aprox. 50.7% (¡Atención aquí!)
30 personas	Aprox. 70.6%
70 personas	¡Sorprendentemente aprox. 99.9%!

Es decir, con solo 23 personas, hay más de la mitad de probabilidad de que alguien comparta cumpleaños. Parece bastante aplicable a una clase en la escuela o a una reunión en el trabajo.

Resumen: La brecha entre la intuición y las matemáticas es interesante

La “paradoja del cumpleaños” es un ejemplo interesante de cómo nuestra intuición y la probabilidad matemática real difieren. ¡Saber este tipo de cosas puede ser divertido para una charla casual o un juego de preguntas!

Enlaces de referencia

Paradoja del cumpleaños (Wikipedia)

El problema de Monty Hall

Sun, 31 Mar 2024 23:41:51 +0900

¿Qué es el problema de Monty Hall?

El problema de Monty Hall es uno de los juegos que se realizaban en el programa de televisión estadounidense “Let’s Make a Deal”, y consiste en el siguiente problema:

Premisa: De tres puertas, una contiene un premio y las otras dos no contienen premio.

El participante elige una de las tres puertas.
El presentador abre una puerta sin premio de entre las dos puertas que el participante no eligió.
Se le pregunta al participante si desea cambiar la puerta elegida.

En este caso, el problema es considerar si es mejor para el participante cambiar de puerta o no cambiarla.

Solución

La solución al problema de Monty Hall es la siguiente:

Si el participante no cambia la puerta que eligió inicialmente
- Probabilidad de ganar: 1/3
- Probabilidad de perder: 2/3
Después de que el presentador abre la puerta sin premio
- Si no cambia, la probabilidad de ganar: 1/3 (no cambia respecto a la probabilidad de ganar del punto 1)
- Si cambia, la probabilidad de ganar: 2/3 (la probabilidad contraria a ganar del punto 1)

Por lo tanto, la probabilidad de ganar es mayor si el participante cambia de puerta.

Referencias

Wikipedia Monty Hall problem

'Problemas no resueltos en matemáticas'

Sat, 02 Mar 2024 22:57:36 +0900

Problemas no resueltos en matemáticas

Explicaremos algunos problemas no resueltos en matemáticas. Aunque los problemas en sí mismos son simples, todavía hay muchos que no han sido demostrados.

¿Hay infinitos números perfectos?

Un número perfecto es un número natural en el que la suma de sus divisores positivos (excluyéndose a sí mismo) es igual al propio número. Por ejemplo,

Los divisores de 6 son 1, 2, 3, y como 1+2+3=6, es un número perfecto.
Los divisores de 28 son 1, 2, 4, 7, 14, y como 1+2+4+7+14=28, es un número perfecto.

Actualmente solo se han descubierto 51, y aunque se conjetura que hay infinitos, todavía no se ha demostrado.

Conjetura de Goldbach

La conjetura de Goldbach sugiere que todo número par mayor que 2 puede expresarse como la suma de dos números primos. (Aquí, un número primo es un número natural que no tiene más divisores que 1 y él mismo).

Por ejemplo,

4=2+2
6=3+3
8=3+5
10=3+7=5+5

Aunque el problema en sí es muy simple, todavía no ha sido demostrado.

Hipótesis de Riemann

Es la conjetura de que los ceros de la función zeta de Riemann se limitan a números pares negativos y a números complejos cuya parte real es 1/2.

La función zeta de Riemann es una función $\zeta$ definida como:

$$\zeta(s):=\sum _{n=1}^{\infty }{\frac {1}{n^{s}}}=1+{\frac {1}{2^{s}}}+{\frac {1}{3^{s}}}+{\frac {1}{4^{s}}}+\cdots$$

donde $s$ es un número complejo y $n$ es un número natural.

'Historia de las Matemáticas'

Sat, 22 Jul 2023 15:25:10 +0900

Tres problemas clásicos de construcción de la antigua Grecia

Dado un círculo, construir un cuadrado con la misma área (Cuadratura del círculo)
Dado un ángulo arbitrario, dividirlo en tres partes iguales (Trisección del ángulo)
Dado un cubo, construir un cubo que tenga el doble de su volumen (Duplicación del cubo)

Espiral de Arquímedes

En un plano, se hace girar una semirrecta OB alrededor de un punto fijo O a una velocidad constante. Si la posición inicial es OA, un punto P parte de O al mismo tiempo que la semirrecta comienza a moverse desde OA, y se mueve a lo largo de OB a una velocidad constante. La curva que traza el punto P es la espiral de Arquímedes.

Teorema de Pappus

Cicloide
Concoide de Nicomedes
Cisoide de Diocles
Método de las tangentes de Fermat
Método de las normales de Descartes

Cronología

Año	Evento
c. 3400 a. C.	Los sumerios cuentan con fichas de arcilla como sustituto de monedas
c. 3000 a. C.	Aparecen las matemáticas jeroglíficas en Egipto
c. 2800 a. C.	La civilización del valle del Indo utiliza un sistema de pesos y medidas basado en el sistema decimal
c. 2700 a. C.	Los egipcios comprueban los ángulos con cuerdas y ternas pitagóricas
c. 2500 a. C.	Se descubre el ábaco, una herramienta para calcular
c. 2500 a. C.

Referencias

Historia de las matemáticas

Cómo enumerar los números primos hasta 1000 usando la criba de Eratóstenes

Sun, 09 Apr 2023 12:54:24 +0900

¿Qué es la criba de Eratóstenes?

La criba de Eratóstenes es un algoritmo para enumerar los números primos menores o iguales a un cierto número. El algoritmo es simple y se puede implementar con los siguientes pasos:

Crear un arreglo de valores booleanos de tamaño N e inicializar todos los elementos a true.
Establecer el 0º y 1º elemento del arreglo a false (porque 0 y 1 no son primos).
Si el 2º elemento del arreglo es true, mostrar 2 como número primo.
Establecer a false todos los elementos del arreglo que sean múltiplos de 2 mayores o iguales a $2^2$*.
Si el 3º elemento del arreglo es true, mostrar 3 como número primo.
Establecer a false todos los elementos del arreglo que sean múltiplos de 3 mayores o iguales a $3^2$.
Repetir el mismo proceso para el 4º, 5º, …, N-ésimo elemento.

*Se dirigen los elementos a partir del cuadrado para convertirlos a false porque los números más pequeños que el cuadrado ya han sido procesados (su enumeración se ha completado).

Implementación en Rust

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


fn main() {
 let n = 1000;
 let mut is_prime = vec![true; n+1];
 is_prime[0] = false;
 is_prime[1] = false;
 for i in 2..=n {
 if is_prime[i] {
 println!("{}", i);
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i;
 }
 }
 }
}

Una versión un poco más rápida

Realizaremos una implementación ligeramente más rápida considerando los siguientes puntos:

Inicializar el arreglo a false en lugar de true (esto es más rápido).
Omitir el proceso de establecer en false los elementos múltiplos de 2, ya que no son primos.
No es necesario iterar hasta n; si enumeramos los primos hasta la raíz cuadrada de n, podremos enumerar todos los primos menores o iguales a n.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


fn main() {
 let n = 1000;
 let mut is_prime = vec![false; n+1];
 is_prime[2] = true;
 for i in (3..=n).step_by(2) {
 is_prime[i] = true;
 }
 for i in 3..=((n as f64).sqrt() as usize) {
 if is_prime[i] {
 let mut j = i * i;
 while j <= n {
 is_prime[j] = false;
 j += i * 2;
 }
 }
 }
 for i in (2..=n).filter(|&x| is_prime[x]) {
 println!("{}", i);
 }
}

Referencia

Criba de Eratóstenes

Cómo dibujar un gráfico usando Python (matplotlib.pyplot)

Sun, 09 Apr 2023 01:02:19 +0900

Requisitos

Cuenta de Google

Procedimiento

Accede a https://colab.research.google.com/
Selecciona “Archivo” → “Nuevo cuaderno”
Pega y ejecuta el siguiente código:

1
2
3
4
5
6
7


import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2*np.pi, 500)
plt.plot(x, np.sin(x), label="sin curve")
plt.plot(x, np.cos(x), label="cos curve")
plt.legend() # Muestra la leyenda
plt.show()

Resultado de la ejecución

Referencias

matplotlib.pyplot — Matplotlib 3.5.3 documentation

Cómo habilitar KaTeX (fórmulas matemáticas estilo LaTeX) en hugo

Fri, 31 Mar 2023 23:11:26 +0900

Qué es KaTeX

KaTeX es una biblioteca de JavaScript para mostrar fórmulas matemáticas estilo LaTeX en HTML.

Específicamente, puedes mostrar fórmulas como la siguiente.

$$f(x) = x^2 + x + 41$$

Aunque parece haber otras bibliotecas para mostrar fórmulas matemáticas estilo LaTeX, KaTeX tiene la reputación de ser simple y rápida.

Cómo introducirlo en hugo

Crea un nuevo archivo layouts/partials/math.html en la jerarquía de carpetas de hugo.

El contenido debe ser el siguiente.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.css" integrity="sha384-vKruj+a13U8yHIkAyGgK1J3ArTLzrFGBbBc0tDp4ad/EyewESeXE/Iv67Aj8gKZ0" crossorigin="anonymous">
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/katex.min.js" integrity="sha384-PwRUT/YqbnEjkZO0zZxNqcxACrXe+j766U2amXcgMg5457rve2Y7I6ZJSm2A0mS4" crossorigin="anonymous"></script>
<script defer src="https://cdn.jsdelivr.net/npm/katex@0.16.4/dist/contrib/auto-render.min.js" integrity="sha384-+VBxd3r6XgURycqtZ117nYw44OOcIax56Z4dCRWbxyPt0Koah1uHoK0o4+/RRE05" crossorigin="anonymous"></script>
<script>
document.addEventListener("DOMContentLoaded", function() {
 renderMathInElement(
 document.body,
 {
 delimiters: [
 {left: "$$", right: "$$", display: true},
 {left: "\\[", right: "\\]", display: true},
 {left: "$", right: "$", display: false},
 {left: "\\(", right: "\\)", display: false}
 ]
 });
 });
</script>

A continuación, añade el siguiente código al archivo existente layouts/partials/extend_head.html.

1
2
3


{{ if or .Params.math .Site.Params.math }}
{{ partial "math.html" . }}
{{ end }}

Ahora estás listo para usar KaTeX.

Al añadir math: true al front matter de la página, puedes habilitar KaTeX.

Todo lo que tienes que hacer es escribir las fórmulas matemáticas al estilo LaTeX en el cuerpo del artículo de la página.

1

$$ e^{i \pi} = -1 $$

Si lo escribes como arriba, se mostrará de la siguiente manera.

$$ e^{i \pi} = -1 $$

Referencias

Resolver el problema del viajante con Mathematica

Wed, 12 Oct 2022 19:05:58 +0900

Resolver el problema del viajante con Mathematica

Problema

電車でこんな広告を見かけました😁📸 pic.twitter.com/iXEgvtXrpL
— 早稲田大学早水桃子研究室 (@hayamizu_lab) October 11, 2022

Solución

1

d=SparseArray[{{1,2}->10,{2,1}->10,{1,5}->15,{5,1}->15,{1,4}->12,{4,1}->12,{1,3}->20,{3,1}->20,{2,5}->10,{5,2}->10,{3,4}->10,{4,3}->10,{3,8}->30,{8,3}->30,{3,7}->20,{7,3}->20,{3,6}->25,{6,3}->25,{4,5}->15,{5,4}->15,{4,8}->20,{8,4}->20,{5,9}->18,{9,5}->18,{5,8}->15,{8,5}->15,{6,7}->5,{7,6}->5,{7,8}->35,{8,7}->35,{8,9}->12,{9,8}->12},{9,9},Infinity];

La función SparseArray crea una matriz. Cada elemento representa la distancia entre las ciudades de la fila y columna de ese elemento. Por ejemplo, el primer elemento {1,2}->10 significa que la distancia entre 1 y 2 es 10. El penúltimo elemento {9,9} indica el tamaño de la matriz, y el último elemento Infinity significa que la longitud del camino entre ciudades no especificadas es infinita. Es decir, significa que no hay camino.

1

{len,tour}=FindShortestTour[{1,2,3,4,5,6,7,8,9},DistanceFunction->(d[[#1,#2]]&)]

Con la función FindShortestTour, puedes resolver fácilmente el problema del viajante. {1,2,3,4,5,6,7,8,9} representa los números de las ciudades. DistanceFunction->(d[[#1,#2]]&) pasa la matriz d que representa la distancia entre las ciudades.

Salida

1

{137, {1, 2, 5, 9, 8, 7, 6, 3, 4}}

La salida es la distancia más corta y el recorrido en ese momento. La distancia más corta es 137, y el recorrido es 1→2→5→9→8→7→6→3→4→1. Convertido al orden ABC, es A, B, E, I, H, G, F, C, D.

'Fórmulas favoritas'

Wed, 05 Oct 2022 13:24:50 +0900

Teorema de Wilson

Cuando $p$ es un número primo, se cumple que $(p−1)!≡−1 \pmod p$

Fórmula de Euler

$e^{iπ}+1=0$

Último teorema de Fermat

Para todo número entero $n≥3$, no existen números enteros positivos $x,y,z$ que cumplan $x^n+y^n=z^n$

Problema de Basilea

$1/1^2+1/2^2+1/3^2+1/4^2+...=π^2/6$

Fórmula de los números primos de Euler

$n^2+n+41$ da como resultado un número primo para todos los números enteros $n$ desde $0$ hasta $39$

[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).