Algorithms on kenji.blog

¡Frecuente en programación competitiva! Guía completa de algoritmos de grafos

Sat, 12 Sep 2026 05:00:00 +0900

En la programación competitiva, la teoría de grafos y sus algoritmos son uno de los temas más importantes que no se pueden evitar. Muchos de los problemas que aparecen en concursos como AtCoder, Codeforces y TopCoder tienen una estructura de grafo subyacente. Se convierten en una poderosa arma para abstraer y resolver problemas del mundo real, como el camino más corto en una red de carreteras, la minimización del costo de comunicación en una red y la resolución de dependencias de tareas.

En este artículo, cubriremos por completo los principales algoritmos de grafos que aparecen con frecuencia en la programación competitiva (ordenamiento topológico, algoritmo de Dijkstra, algoritmo de Bellman-Ford, algoritmo de Floyd-Warshall, algoritmo de Kruskal, algoritmo de Prim, descomposición en componentes fuertemente conexas), incluyendo su base teórica, evaluación de la complejidad computacional usando fórmulas matemáticas, y ejemplos de implementación altamente optimizados en C++ moderno (C++17/20). ¡Es una verdadera guía de “conquista total” entregada en un gran volumen de aproximadamente 10,000 caracteres!

1. Fundamentos y restricciones de los algoritmos de grafos

Antes de aprender los algoritmos, es importante comprender las restricciones generales y los estándares de complejidad computacional de los problemas de grafos en la programación competitiva. Un grafo se representa por el número de vértices $V$ (Vertices) y el número de aristas $E$ (Edges).

$O(V + E)$ : Es la complejidad computacional requerida para problemas con un número de vértices $V, E \le 10^5 \sim 10^6$. La búsqueda en profundidad (DFS) y la búsqueda en anchura (BFS) entran en esta categoría.
$O((V + E) \log V)$ : Frecuente en problemas con $V, E \le 10^5 \sim 2 \cdot 10^5$. Es la complejidad computacional cuando se usa una cola de prioridad en algoritmos como Dijkstra o Prim.
$O(V^2)$ : Permitido en grafos densos ($E \approx V^2$) con $V \le 2000 \sim 3000$.
$O(V^3)$ : Problemas con $V \le 400 \sim 500$. El algoritmo de Floyd-Warshall es representativo.

En la programación competitiva, es común usar listas de adyacencia (Adjacency List) para representar grafos. Dado que una matriz de adyacencia consume memoria $O(V^2)$, causaría un error de límite de memoria (Memory Limit Exceeded) en problemas con un gran número de vértices.

2. Búsqueda y ordenamiento de grafos

Ordenamiento topológico (Topological Sort)

El ordenamiento topológico es un algoritmo que organiza los vértices de un grafo dirigido acíclico (DAG: Directed Acyclic Graph) en una línea de manera que todas las aristas dirigidas vayan de los vértices anteriores a los posteriores. Se utiliza para resolver dependencias de tareas (por ejemplo, la tarea B no puede comenzar hasta que termine la tarea A) o para determinar el orden de cálculo en la programación dinámica (DP) sobre un DAG.

La complejidad computacional es $O(V + E)$. Existen dos tipos de implementación: el algoritmo de Kahn (basado en BFS usando los grados de entrada) y el basado en DFS usando el tiempo de finalización. Aquí presentaremos el algoritmo de Kahn, que también permite encontrar fácilmente el ordenamiento topológico mínimo lexicográficamente.

graph LR A["Tarea A"] --> B["Tarea B"] A["Tarea A"] --> C["Tarea C"] B["Tarea B"] --> D["Tarea D"] C["Tarea C"] --> D["Tarea D"] E["Tarea E"] --> C["Tarea C"]

Ejemplo de implementación en C++ (Algoritmo de Kahn)

 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


#include <iostream>
#include <vector>
#include <queue>

using namespace std;

// Función para realizar el ordenamiento topológico
// Si existe un ciclo, devuelve un arreglo vacío
vector<int> topological_sort(int V, const vector<vector<int>>& graph) {
 vector<int> in_degree(V, 0);
 // Calcular los grados de entrada
 for (int u = 0; u < V; ++u) {
 for (int v : graph[u]) {
 in_degree[v]++;
 }
 }

 // Agregar vértices con grado de entrada 0 a la cola (si se desea el menor lexicográficamente, usar priority_queue<int, vector<int>, greater<int>>)
 queue<int> q;
 for (int i = 0; i < V; ++i) {
 if (in_degree[i] == 0) {
 q.push(i);
 }
 }

 vector<int> res;
 while (!q.empty()) {
 int u = q.front();
 q.pop();
 res.push_back(u);

 // Disminuir el grado de entrada de los vértices adyacentes
 for (int v : graph[u]) {
 in_degree[v]--;
 if (in_degree[v] == 0) {
 q.push(v);
 }
 }
 }

 // Comprobar si el grafo contiene un ciclo
 if (res.size() != V) {
 return {}; // Ciclo detectado
 }
 return res;
}

3. Problema del camino más corto desde un solo origen (SSSP: Single Source Shortest Path)

Es el problema de encontrar los caminos más cortos desde un vértice de origen a todos los demás vértices. El algoritmo aplicable varía dependiendo de si los pesos de las aristas son no negativos o si existen pesos negativos.

Algoritmo de Dijkstra (Dijkstra’s Algorithm)

El algoritmo de Dijkstra es un algoritmo rápido de camino más corto que se puede aplicar cuando todos los pesos de las aristas son no negativos. Se basa en un enfoque codicioso (greedy): “fijar el vértice con la distancia más corta conocida actualmente, y actualizar la distancia a sus vértices adyacentes (relajación)”.

Fórmula de relajación (Relaxation)

Sea $s$ el vértice de origen, $d[u]$ la distancia más corta al vértice $u$, y $w(u, v)$ el peso de la arista $(u, v)$. La fórmula de actualización es la siguiente:

$$ d[v] = \min(d[v], d[u] + w(u, v)) $$

Usando una cola de prioridad (std::priority_queue), el vértice no fijado con la distancia mínima se puede extraer en $O(\log V)$, y la complejidad temporal total es $O((V + E) \log V)$. La complejidad espacial es $O(V + E)$.

graph TD S["Origen S(0)"] -- "2" --> A["Vértice A(2)"] S["Origen S(0)"] -- "5" --> B["Vértice B(5)"] A["Vértice A(2)"] -- "1" --> B["Vértice B(3)"] A["Vértice A(2)"] -- "4" --> C["Vértice C(6)"] B["Vértice B(3)"] -- "1" --> C["Vértice C(4)"]

Como se muestra en la figura anterior, el costo de ir directamente de S a B es 5, pero pasando por A, se puede llegar con un costo de 3. El algoritmo de Dijkstra realiza optimizaciones de esta manera.

Ejemplo de implementación en C++

 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


#include <iostream>
#include <vector>
#include <queue>

using namespace std;

const long long INF = 1e18; // Un valor lo suficientemente grande

struct Edge {
 int to;
 long long weight;
};

// Algoritmo de Dijkstra
// Devuelve el arreglo de distancias más cortas desde el origen s a cada vértice
vector<long long> dijkstra(int V, const vector<vector<Edge>>& graph, int s) {
 vector<long long> dist(V, INF);
 dist[s] = 0;

 // Cola de prioridad que gestiona {distancia, vértice} (en orden ascendente de distancia)
 using P = pair<long long, int>;
 priority_queue<P, vector<P>, greater<P>> pq;
 pq.push({0, s});

 while (!pq.empty()) {
 auto [d, u] = pq.top();
 pq.pop();

 // Si ya se ha encontrado un camino más corto, omitir (descartar información obsoleta)
 if (dist[u] < d) continue;

 // Proceso de relajación
 for (const auto& edge : graph[u]) {
 int v = edge.to;
 long long cost = edge.weight;
 if (dist[v] > dist[u] + cost) {
 dist[v] = dist[u] + cost;
 pq.push({dist[v], v});
 }
 }
 }
 return dist;
}

La línea if (dist[u] < d) continue; es muy importante. En el algoritmo de Dijkstra, el mismo vértice puede ser empujado a la cola varias veces, pero esta verificación poda la búsqueda innecesaria.

Algoritmo de Bellman-Ford (Bellman-Ford Algorithm)

Cuando los pesos de las aristas incluyen valores negativos, el algoritmo de Dijkstra no puede encontrar la respuesta correcta. En este caso, el algoritmo de Bellman-Ford es muy útil. Repitiendo el proceso de relajación para todas las aristas $V - 1$ veces, calcula correctamente los caminos más cortos incluso si hay pesos negativos.

Si ocurre una actualización en la iteración $V$-ésima, significa que existe un ciclo negativo (Negative Cycle). En programación competitiva, el problema de “detectar ciclos negativos” es frecuente, y el algoritmo de Bellman-Ford también es excelente como algoritmo de detección.

La complejidad temporal es $O(V \times E)$, por lo que es más lento que el algoritmo de Dijkstra, ten en cuenta que solo se puede aplicar a restricciones de alrededor de $V \le 2000, E \le 5000$.

Ejemplo de implementación en C++

 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


#include <iostream>
#include <vector>

using namespace std;

const long long INF = 1e18;

struct Edge {
 int from;
 int to;
 long long weight;
};

// Algoritmo de Bellman-Ford
// Valor de retorno: {arreglo de distancias más cortas, si existe o no un ciclo negativo}
pair<vector<long long>, bool> bellman_ford(int V, const vector<Edge>& edges, int s) {
 vector<long long> dist(V, INF);
 dist[s] = 0;
 bool negative_cycle = false;

 // Repetir el bucle V veces
 for (int i = 0; i < V; ++i) {
 bool updated = false;
 for (const auto& edge : edges) {
 if (dist[edge.from] != INF && dist[edge.to] > dist[edge.from] + edge.weight) {
 dist[edge.to] = dist[edge.from] + edge.weight;
 updated = true;
 // Si ocurre una actualización en la iteración V, existe un ciclo negativo
 if (i == V - 1) {
 negative_cycle = true;
 }
 }
 }
 // Si no hay actualizaciones, terminar anticipadamente (optimización)
 if (!updated) break;
 }

 return {dist, negative_cycle};
}

4. Problema de caminos más cortos entre todos los pares (APSP: All-Pairs Shortest Path)

Algoritmo de Floyd-Warshall (Floyd-Warshall Algorithm)

Es un algoritmo para encontrar la distancia más corta entre todos los pares de vértices de un grafo. Se basa en la programación dinámica (DP). Su gran atractivo es que el algoritmo es muy conciso y la implementación es extremadamente sencilla.

La ecuación de transición de estado es la siguiente. Toma el más corto entre el camino que pasa por el vértice $k$ y el camino que no lo hace:

$$ d[i][j] = \min(d[i][j], d[i][k] + d[k][j]) $$

Debido a que utiliza tres bucles anidados, la complejidad temporal es $O(V^3)$ y la complejidad espacial es $O(V^2)$. Si el número de vértices es alrededor de $V \le 400$, estará dentro del límite de tiempo de ejecución (generalmente 2 segundos).

Ejemplo de implementación en C++

 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


#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

const long long INF = 1e18;

// Algoritmo de Floyd-Warshall
// dist[i][j] es inicialmente el peso de la arista de i a j (si no hay arista es INF, si i==j es 0)
void floyd_warshall(int V, vector<vector<long long>>& dist) {
 // Vértice intermedio k
 for (int k = 0; k < V; ++k) {
 // Vértice de origen i
 for (int i = 0; i < V; ++i) {
 // Vértice de destino j
 for (int j = 0; j < V; ++j) {
 // Comprobar si es INF para evitar desbordamiento (overflow)
 if (dist[i][k] != INF && dist[k][j] != INF) {
 dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
 }
 }
 }
 }
}

El algoritmo de Floyd-Warshall también puede detectar ciclos negativos. Después de que finalice el bucle, si existe al menos un vértice i donde dist[i][i] < 0, entonces el grafo contiene un ciclo negativo.

5. Árbol de expansión mínima (MST: Minimum Spanning Tree)

En un grafo no dirigido conexo, un árbol (subgrafo sin ciclos) que conecta todos los vértices y cuya suma de los pesos de las aristas es la mínima, se llama árbol de expansión mínima (MST). A menudo se pregunta directamente en problemas como minimizar el costo de instalación de una red.

Algoritmo de Kruskal (Kruskal’s Algorithm)

Es un método codicioso que ordena todas las aristas en orden ascendente de su peso y las selecciona una por una asegurándose de que no formen ciclos. La detección de ciclos se puede realizar rápidamente utilizando una estructura de datos de conjuntos disjuntos (Union-Find, Disjoint Set).

La complejidad temporal está dominada por el ordenamiento de las aristas y es $O(E \log E)$. Es el algoritmo de construcción de MST que se utiliza con más frecuencia en la programación competitiva.

graph TD A["Vértice A"] -- "1 (Adoptada)" --- B["Vértice B"] B["Vértice B"] -- "2 (Adoptada)" --- C["Vértice C"] C["Vértice C"] -- "3 (Adoptada)" --- D["Vértice D"] A["Vértice A"] -- "4 (Descartada: Ciclo)" --- D["Vértice D"]

Ejemplo de implementación en C++

 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


#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

// Union-Find (Estructura de datos de conjuntos disjuntos)
struct UnionFind {
 vector<int> parent, rank, size;
 UnionFind(int n) : parent(n), rank(n, 0), size(n, 1) {
 for (int i = 0; i < n; i++) parent[i] = i;
 }
 int find(int x) {
 if (parent[x] == x) return x;
 // Compresión de caminos
 return parent[x] = find(parent[x]);
 }
 bool unite(int x, int y) {
 int root_x = find(x);
 int root_y = find(y);
 if (root_x == root_y) return false;

 // Unión por rango
 if (rank[root_x] < rank[root_y]) swap(root_x, root_y);
 parent[root_y] = root_x;
 if (rank[root_x] == rank[root_y]) rank[root_x]++;
 size[root_x] += size[root_y];
 return true;
 }
 bool same(int x, int y) { return find(x) == find(y); }
};

struct Edge {
 int u, v;
 long long weight;
 // Función de comparación para ordenar
 bool operator<(const Edge& other) const {
 return weight < other.weight;
 }
};

// Algoritmo de Kruskal
long long kruskal(int V, vector<Edge>& edges) {
 // Ordenar aristas por peso de forma ascendente
 sort(edges.begin(), edges.end());

 UnionFind uf(V);
 long long mst_cost = 0;
 int edge_count = 0;

 for (const auto& edge : edges) {
 if (uf.unite(edge.u, edge.v)) {
 mst_cost += edge.weight;
 edge_count++;
 // Finaliza cuando se han seleccionado V-1 aristas (optimización)
 if (edge_count == V - 1) break;
 }
 }
 return mst_cost;
}

Algoritmo de Prim (Prim’s Algorithm)

Toma un enfoque muy similar al algoritmo de Dijkstra. Comenzando desde un vértice, hace crecer el árbol secuencialmente eligiendo la arista de menor peso que conecta directamente el árbol ya construido con los vértices restantes.

Cuando se utiliza una cola de prioridad, la complejidad computacional es $O((V + E) \log V)$. En el caso de grafos densos (grafos con muchas aristas), la implementación basada en arreglos del algoritmo de Prim, que es $O(V^2)$, puede ser más rápida que el algoritmo de Kruskal.

Ejemplo de implementación en C++

 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


#include <iostream>
#include <vector>
#include <queue>

using namespace std;

struct Edge {
 int to;
 long long weight;
};

// Algoritmo de Prim
long long prim(int V, const vector<vector<Edge>>& graph) {
 vector<bool> used(V, false);
 // {peso, vértice}
 using P = pair<long long, int>;
 priority_queue<P, vector<P>, greater<P>> pq;

 long long mst_cost = 0;
 // Comenzar desde el vértice 0
 pq.push({0, 0});

 while (!pq.empty()) {
 auto [cost, u] = pq.top();
 pq.pop();

 if (used[u]) continue;
 used[u] = true;
 mst_cost += cost;

 for (const auto& edge : graph[u]) {
 if (!used[edge.to]) {
 pq.push({edge.weight, edge.to});
 }
 }
 }
 return mst_cost;
}

6. Avanzado: Descomposición en componentes fuertemente conexas (SCC: Strongly Connected Components)

En un grafo dirigido, un “conjunto de vértices que pueden alcanzarse entre sí” se llama componente fuertemente conexa (SCC). Al agrupar un grafo dirigido arbitrario por sus SCC, el grafo general siempre se convierte en un DAG (grafo dirigido acíclico). A esto se le llama descomposición en componentes fuertemente conexas. Es un preprocesamiento muy importante para simplificar la estructura del grafo y facilitar la resolución del problema.

En la programación competitiva, se utiliza ampliamente para resolver problemas 2-SAT y para realizar DP al reducir grafos con ciclos a DAGs.

Algoritmo de Kosaraju (Kosaraju’s Algorithm)

El algoritmo de Kosaraju es un método elegante y eficiente para construir SCC utilizando solo dos búsquedas en profundidad (DFS). Funciona en tiempo lineal con una complejidad de $O(V + E)$.

Pasos del algoritmo:

Realizar un DFS en el grafo original y registrar los vértices en un arreglo en orden posterior (post-order).
Crear un grafo transpuesto (inverso) invirtiendo la dirección de todas las aristas.
Desde el final del arreglo registrado en el paso 1 (es decir, los de último tiempo de finalización), realizar DFS desde los vértices no visitados en el grafo inverso. El conjunto de vértices alcanzados en cada DFS forma una SCC.

graph TD subgraph "SCC 1" A["Vértice A"] --> B["Vértice B"] B["Vértice B"] --> A["Vértice A"] end subgraph "SCC 2" C["Vértice C"] --> D["Vértice D"] D["Vértice D"] --> C["Vértice C"] end B["Vértice B"] --> C["Vértice C"]

Ejemplo de implementación en C++

 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


#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct SCC {
 int V;
 vector<vector<int>> graph, rev_graph;
 vector<int> order, comp;
 vector<bool> used;

 SCC(int n) : V(n), graph(n), rev_graph(n), comp(n, -1), used(n, false) {}

 void add_edge(int from, int to) {
 graph[from].push_back(to);
 rev_graph[to].push_back(from);
 }

 // Primer DFS (registro en post-order)
 void dfs1(int u) {
 used[u] = true;
 for (int v : graph[u]) {
 if (!used[v]) dfs1(v);
 }
 order.push_back(u);
 }

 // Segundo DFS (búsqueda en el grafo inverso)
 void dfs2(int u, int id) {
 used[u] = true;
 comp[u] = id;
 for (int v : rev_graph[u]) {
 if (!used[v]) dfs2(v, id);
 }
 }

 // Proceso de construcción de SCC. Devuelve el número de grupos de SCC
 int build() {
 // Primer DFS
 for (int i = 0; i < V; ++i) {
 if (!used[i]) dfs1(i);
 }

 fill(used.begin(), used.end(), false);
 int group_id = 0;

 // Segundo DFS (en orden inverso de order)
 for (int i = V - 1; i >= 0; --i) {
 int u = order[i];
 if (!used[u]) {
 dfs2(u, group_id++);
 }
 }
 return group_id;
 }
};

El arreglo comp almacenará el ID de la SCC a la que pertenece cada vértice. De hecho, este ID tiene la característica muy útil de estar asignado en orden topológico. En otras palabras, al observar los valores de comp, se pueden conocer inmediatamente las dependencias después de reducir a un DAG.

7. Resumen y consejos para el aprendizaje

En este artículo, hemos revisado los algoritmos de grafos que aparecen con frecuencia en la programación competitiva. La clave para mejorar en los problemas de grafos es “implementarlos una y otra vez hasta que se convierta en un hábito” y “entrenarse para pensar a qué modelo de grafo se puede reducir este problema (cuáles son los vértices y cuáles son las aristas)”.

Primero, asegúrate de poder escribir DFS / BFS rápido y sin errores.
A continuación, asegúrate de poder escribir los algoritmos de Dijkstra y Kruskal de memoria (imprescindible en las categorías marrón a verde de AtCoder).
Por último, aumenta tus recursos aprendiendo algoritmos como Bellman-Ford, Floyd-Warshall, ordenamiento topológico y SCC (se convierten en un arma en las categorías celeste a azul de AtCoder).

Es altamente recomendable guardar tu código como una biblioteca de fragmentos (en una herramienta de fragmentos o en tu repositorio de GitHub) para poder utilizarlo sin dudar durante las competiciones.

Los algoritmos de grafos en la programación competitiva son el área donde más se puede experimentar la belleza y el poder de los algoritmos. ¡Te animamos a copiar el código de este artículo y a desafiar preguntas pasadas en jueces en línea!

¡Imprescindible para los amantes de las matemáticas! 10 hermosas fórmulas matemáticas útiles para la programación

Sat, 12 Sep 2026 01:00:00 +0900

¡Imprescindible para los amantes de las matemáticas! 10 hermosas fórmulas matemáticas útiles para la programación

La programación y las matemáticas pueden parecer, a primera vista, campos completamente diferentes. La programación es la tarea de escribir código lógico y concreto, mientras que las matemáticas son el estudio que persigue verdades abstractas y universales. Sin embargo, las matemáticas siempre están presentes en la base de la informática. En la optimización de algoritmos, ciencia de datos, aprendizaje automático, gráficos por computadora, e incluso detrás de las aplicaciones cotidianas, hermosas fórmulas matemáticas están trabajando silenciosa y poderosamente.

En este artículo, hemos seleccionado 10 fórmulas que no solo son matemáticamente hermosas, sino que también desempeñan un papel muy práctico e importante en el contexto de la programación y los algoritmos. Profundizaremos en los fundamentos matemáticos de cada fórmula y explicaremos detalladamente cómo se aplican en la práctica de la programación, junto con fragmentos de código concretos en Python y C++.

Bienvenido a un mundo donde la belleza de las matemáticas y la practicidad de la programación se cruzan.

1. Identidad de Euler (Euler’s Identity)

Belleza matemática y resumen

Esta es la Identidad de Euler, a menudo llamada “el tesoro de la humanidad” o “la fórmula más hermosa del mundo”. Cinco de las constantes más importantes de las matemáticas (el número de Euler $e$, la unidad imaginaria $i$, pi $\pi$, el elemento neutro multiplicativo $1$ y el elemento neutro aditivo $0$) se integran en una sola ecuación simple.

$$ e^{i\pi} + 1 = 0 $$

Esta identidad se deriva sustituyendo $\theta = \pi$ en la fórmula general de Euler $e^{i\theta} = \cos\theta + i\sin\theta$.

Aplicaciones en programación

En programación, especialmente en gráficos por computadora y desarrollo de videojuegos, la fórmula de Euler es una herramienta extremadamente poderosa para manejar “rotaciones”. La rotación de puntos en un espacio bidimensional se puede realizar con cálculos matriciales, pero el uso de números complejos hace que el cálculo sea extremadamente simple e intuitivo. Una rotación en el plano complejo se puede lograr simplemente multiplicando por $e^{i\theta}$, lo que resulta en un código conciso.

Ejemplo de implementación (C++)

A continuación se muestra un programa que utiliza la biblioteca estándar de C++ <complex> para rotar un punto en coordenadas bidimensionales en un ángulo especificado (en radianes).

 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


#include <iostream>
#include <complex>
#include <cmath>

// Alias de tipo para tratar las coordenadas 2D como números complejos
using Point2D = std::complex<double>;

// Función para rotar un punto theta (radianes) alrededor del origen
Point2D rotatePoint(const Point2D& point, double theta) {
 // Crea el número complejo para rotación e^{i*theta} basado en la fórmula de Euler
 // Internamente se convierte en cos(theta) + i*sin(theta)
 Point2D rotation(std::cos(theta), std::sin(theta));

 // Aplica la rotación multiplicando los números complejos
 return point * rotation;
}

int main() {
 // Coordenada inicial (x=1.0, y=0.0)
 Point2D p(1.0, 0.0);

 // Rotación de 90 grados (π/2 radianes)
 double theta = M_PI / 2.0;
 Point2D rotated_p = rotatePoint(p, theta);

 std::cout << "Original Point: (" << p.real() << ", " << p.imag() << ")\n";
 // La salida esperada es aproximadamente (0, 1)
 std::cout << "Rotated Point: (" << rotated_p.real() << ", " << rotated_p.imag() << ")\n";

 return 0;
}

Explicación detallada: La ventaja de este enfoque es que encapsula el cálculo de la matriz de rotación (4 multiplicaciones y 2 sumas) como una operación de números complejos. Además, en el espacio tridimensional, se utiliza una extensión de este concepto llamada “cuaterniones” (quaternions). Usando cuaterniones, se puede evitar el problema fatal del “bloqueo del cardán” (Gimbal Lock) que ocurre con los ángulos de Euler, permitiendo una interpolación esférica lineal suave (Slerp).

2. Serie de Taylor (Taylor Series)

Belleza matemática y resumen

La serie de Taylor es un método matemático para expresar funciones complejas (como funciones trigonométricas y exponenciales) como una suma infinita de polinomios. La serie de Taylor de una función $f(x)$ alrededor de un punto $a$ se define de la siguiente manera:

$$ f(x) = \sum_{n=0}^\infty \frac{f^{(n)}(a)}{n!}(x-a)^n $$

El caso especial donde $a=0$ se conoce como la “serie de Maclaurin”.

Aplicaciones en programación

Las computadoras (CPU y FPU) fundamentalmente solo pueden realizar operaciones aritméticas básicas como suma, resta, multiplicación y división. Entonces, ¿cómo se calculan sin(x) o exp(x)? En los procesadores modernos se suelen utilizar algoritmos CORDIC o la aproximación de Chebyshev, pero cuando se implementan funciones matemáticas a nivel de software, o al crear funciones de aproximación rápidas con menor precisión para un mejor rendimiento, la serie de Taylor (o sus variantes) es directamente útil.

Ejemplo de implementación (Python)

A continuación se muestra un código en Python que aproxima la función seno (Sine) utilizando la serie de Maclaurin.

$$ \sin(x) \approx x - \frac{x^3}{3!} + \frac{x^5}{5!} - \frac{x^7}{7!} + \dots $$

 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


import math

def taylor_sin(x, terms=10):
 """
 Aproxima sin(x) usando la serie de Taylor (serie de Maclaurin).

 :param x: Ángulo (radianes)
 :param terms: Número de términos a calcular (más términos = mayor precisión)
 :return: Valor aproximado de sin(x)
 """
 # Normaliza x al rango de -π a π usando su periodicidad (para mejorar la precisión)
 x = (x + math.pi) % (2 * math.pi) - math.pi

 result = 0.0
 for n in range(terms):
 # Usa solo los términos impares: 2n + 1
 power = 2 * n + 1

 # El signo se alterna por término: (-1)^n
 sign = (-1) ** n

 # Cálculo del factorial
 fact = math.factorial(power)

 # Evaluación de la expresión y suma
 term = sign * (x ** power) / fact
 result += term

 return result

# Prueba
angle = math.radians(45) # 45 grados = π/4
print(f"Math library sin: {math.sin(angle)}")
print(f"Taylor series sin: {taylor_sin(angle, terms=5)}")

Explicación detallada: En el código anterior, el valor de entrada x se normaliza al rango $[-\pi, \pi]$. Esto se debe a que el error de truncamiento de la serie de Taylor aumenta rápidamente cuanto más se aleja del centro de expansión (aquí 0). Como los cálculos infinitos son imposibles en programación, el cálculo se detiene después de un número finito de terms, y gestionar el equilibrio entre el “error de redondeo” y el “error de truncamiento” causado por esto es el núcleo de la programación de cálculos numéricos.

3. Teorema de Bayes (Bayes’ Theorem)

Belleza matemática y resumen

El teorema de Bayes es un teorema para actualizar la probabilidad de un evento (probabilidad a posteriori) en función del conocimiento previo relacionado con ese evento (probabilidad a priori). Es una de las fórmulas más importantes en teoría de la probabilidad y estadística.

$$ P(A|B) = \frac{P(B|A)P(A)}{P(B)} $$

Aquí, $P(A|B)$ representa la probabilidad de que el evento A ocurra bajo la condición de que el evento B haya ocurrido (probabilidad a posteriori).

Aplicaciones en programación

Se utiliza ampliamente en los campos del aprendizaje automático y ciencia de datos como el “clasificador Bayesiano ingenuo” (Naive Bayes Classifier). Un ejemplo típico de aplicación es el filtrado de correos no deseados (spam). La pregunta “Si este correo contiene la palabra ‘gratis’, ¿cuál es la probabilidad de que sea spam?” se calcula dinámicamente en función de datos históricos.

graph TD Email["Correo Entrante"] --> Extract["Extraer Palabras"] Extract --> W1["Palabra: 'Gratis'"] Extract --> W2["Palabra: 'Dinero'"] Extract --> Wn["Palabra: 'Reunión'"] W1 --> Prob["Calcular P(Spam | Palabras)"] W2 --> Prob Wn --> Prob Prob --> Bayes["Aplicar Teorema de Bayes"] Bayes --> Class{"¿P(Spam) > 0.9?"} Class -- "Sí" --> Spam["Mover a Carpeta de Spam"] Class -- "No" --> Ham["Entregar a la Bandeja de Entrada"]

Ejemplo de implementación (Python)

Código que muestra la lógica básica de un filtro de spam.

 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


def calculate_spam_probability(
 prob_spam,
 prob_word_given_spam,
 prob_word_given_ham
):
 """
 Calcula la probabilidad de que un correo sea spam si contiene una palabra usando el teorema de Bayes.

 :param prob_spam: P(Spam) - Probabilidad a priori de que el correo sea spam
 :param prob_word_given_spam: P(Palabra|Spam) - Probabilidad de que la palabra esté en un correo spam
 :param prob_word_given_ham: P(Palabra|Ham) - Probabilidad de que la palabra esté en un correo normal
 :return: P(Spam|Palabra) - Probabilidad de que sea spam si contiene esa palabra
 """
 # Probabilidad a priori de correo normal P(Ham) = 1 - P(Spam)
 prob_ham = 1.0 - prob_spam

 # Probabilidad de aparición de la palabra en todos los correos P(Palabra) = P(Palabra|Spam)P(Spam) + P(Palabra|Ham)P(Ham)
 # Esto es por la ley de probabilidad total
 prob_word = (prob_word_given_spam * prob_spam) + (prob_word_given_ham * prob_ham)

 # Teorema de Bayes P(Spam|Palabra) = P(Palabra|Spam) * P(Spam) / P(Palabra)
 if prob_word == 0:
 return 0.0 # Evitar división por cero

 prob_spam_given_word = (prob_word_given_spam * prob_spam) / prob_word
 return prob_spam_given_word

# Ejemplo: Probabilidad de la palabra "ganador"
# Datos pasados: 20% de todos los correos son spam
p_spam = 0.2
# 80% de los correos spam contienen la palabra "ganador"
p_win_given_spam = 0.8
# 1% de los correos normales contienen la palabra "ganador"
p_win_given_ham = 0.01

result = calculate_spam_probability(p_spam, p_win_given_spam, p_win_given_ham)
print(f"Probabilidad de que un correo con la palabra 'ganador' sea spam: {result:.2%}")

Explicación detallada: En una implementación real (clasificador Bayesiano ingenuo), se multiplican las probabilidades de múltiples palabras. Sin embargo, si multiplicamos miles de veces probabilidades (valores entre 0 y 1), el valor se convierte en cero debido a los límites de representación de punto flotante de la computadora (subdesbordamiento o underflow). Por lo tanto, en la programación real, la técnica de convertir el producto de las probabilidades en “suma de logaritmos” (log(a * b) = log(a) + log(b)) es indispensable.

4. Entropía de Shannon (Shannon Entropy)

Belleza matemática y resumen

La “entropía” definida por Claude Shannon, el padre de la teoría de la información, es una fórmula que cuantifica la “incertidumbre”, el “desorden” o la “cantidad promedio de información” que posee una fuente de información.

$$ H(X) = - \sum_{i=1}^n P(x_i) \log_2 P(x_i) $$

Aplicaciones en programación

La entropía es esencial en la compresión de datos de archivos (el límite teórico de la codificación Huffman y algoritmos de compresión ZIP), la evaluación de la fortaleza de los números aleatorios en criptografía, y en algoritmos de “árboles de decisión” (Decision Trees) en aprendizaje automático (como ID3 y C4.5). Al construir un árbol de decisión, el objetivo es encontrar la característica que maximice la reducción de la entropía (Ganancia de Información: Information Gain) al dividir los datos.

Ejemplo de implementación (Python)

Una función que calcula la entropía de una cadena (conjunto de datos) y evalúa su cantidad de informació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


import math
from collections import Counter

def calculate_entropy(data):
 """
 Calcula la entropía de Shannon del conjunto de datos proporcionado (cadena o lista).
 """
 if not data:
 return 0.0

 # Contar las ocurrencias de cada elemento
 counts = Counter(data)
 total_len = len(data)

 entropy = 0.0
 for element, count in counts.items():
 # Probabilidad de aparición P(x_i)
 probability = count / total_len

 # - P(x_i) * log2(P(x_i))
 entropy -= probability * math.log2(probability)

 return entropy

# Prueba
# Si todos son la misma letra, la incertidumbre es 0
data_deterministic = "AAAAAAAAAA"
# Si los caracteres son aleatorios, la incertidumbre es alta
data_random = "ABACBCBACB"

print(f"Entropy of '{data_deterministic}': {calculate_entropy(data_deterministic)}")
print(f"Entropy of '{data_random}': {calculate_entropy(data_random)}")

Explicación detallada: La unidad de la entropía son los “bits” (bits). Si la entropía es 1.5, significa que, en promedio, se requieren al menos 1.5 bits por elemento para representar esa información. En la práctica de la programación, se calcula habitualmente como punto de referencia para medir la eficiencia de los algoritmos de compresión, o como indicador crucial para la selección de características en modelos de aprendizaje automático.

5. Transformada Rápida de Fourier (Fast Fourier Transform - FFT)

Belleza matemática y resumen

La Transformada Discreta de Fourier (DFT) transforma una señal en el dominio del tiempo a una señal en el dominio de la frecuencia. Su fórmula matemática es la siguiente:

$$ X_k = \sum_{n=0}^{N-1} x_n e^{-i 2\pi k n / N} $$

Si esta DFT se calcula ingenuamente, la complejidad computacional (complejidad temporal) es de $O(N^2)$, y el cálculo se vuelve explosivamente lento a medida que aumenta la cantidad de datos. El algoritmo que acelera esto dramáticamente hasta $O(N \log N)$ mediante el enfoque de divide y vencerás es la “Transformada Rápida de Fourier (FFT)”. Se considera uno de los 10 algoritmos más importantes del siglo XX.

graph TD A["Arreglo de entrada de tamaño N"] --> B["Dividir en índices pares e impares"] B --> C["Índices pares (N/2)"] B --> D["Índices impares (N/2)"] C --> E["FFT recursiva en pares"] D --> F["FFT recursiva en impares"] E --> G["Combinar usando factores de rotación"] F --> G G --> H["Espectro de frecuencia de salida"]

Aplicaciones en programación

La FFT es una tecnología indispensable que sustenta la sociedad moderna. Funciona en todas partes, desde el reconocimiento de voz (Siri o Alexa), compresión de datos de MP3 y JPEG/MPEG, comunicaciones digitales como LTE y Wi-Fi, e incluso en la multiplicación de enteros muy grandes (algoritmo de Schönhage-Strassen).

Ejemplo de implementación (Python)

Un ejemplo de implementación simple de un algoritmo recursivo tipo Cooley-Tukey. (※ En la práctica, se usan librerías optimizadas al extremo en C o ensamblador, como FFTW o numpy.fft)

 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


import cmath

def fft(x):
 """
 Calcula la Transformada Rápida de Fourier (FFT) en 1D (método Cooley-Tukey).
 La longitud N de la lista de entrada debe ser una potencia de 2.
 """
 N = len(x)

 # Caso base
 if N <= 1:
 return x

 # Dividir en elementos pares e impares (Divide)
 even = fft(x[0::2])
 odd = fft(x[1::2])

 # Combinar resultados (Conquer)
 T = [cmath.exp(-2j * cmath.pi * k / N) * odd[k] for k in range(N // 2)]

 # Aprovechar la simetría para reducir los cálculos
 return [even[k] + T[k] for k in range(N // 2)] + \
 [even[k] - T[k] for k in range(N // 2)]

# Prueba: Señal simple
signal = [1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0]
spectrum = fft(signal)

print("Frequency Spectrum (Magnitude):")
for k, val in enumerate(spectrum):
 # Calcular el valor absoluto (amplitud)
 print(f"Freq {k}: {abs(val):.3f}")

Explicación detallada: El núcleo de este algoritmo está en explotar la simetría y la periodicidad del número complejo llamado “factor de rotación (Twiddle factor)”. Al evitar repetir cálculos redundantes, cuando $N=1024$, los cálculos necesarios se reducen de $1,048,576$ a apenas unos $10,240$. Es verdaderamente un milagro nacido de la fusión entre matemáticas y algoritmos.

6. Fórmula del semiverseno (Haversine Formula)

Belleza matemática y resumen

Es una fórmula para calcular la distancia más corta (distancia ortodrómica o distancia del gran círculo) entre dos puntos en una superficie esférica, como la superficie de la Tierra.

$$ a = \sin^2\left(\frac{\Delta\phi}{2}\right) + \cos\phi_1 \cos\phi_2 \sin^2\left(\frac{\Delta\lambda}{2}\right) $$ $$ c = 2\cdot \text{atan2}\left(\sqrt{a}, \sqrt{1-a}\right) $$ $$ d = R \cdot c $$

(Donde $\phi$ es la latitud, $\lambda$ es la longitud y $R$ es el radio de la Tierra).

Aplicaciones en programación

Es una fórmula esencial al calcular la distancia entre dos coordenadas de latitud y longitud en aplicaciones de rastreo GPS, y servicios basados en ubicación como Uber o Pokémon GO. Calcular la distancia lineal usando el teorema de Pitágoras produce grandes errores en largas distancias porque no toma en cuenta la curvatura de la Tierra.

Ejemplo de implementación (Python)

Una función que toma dos coordenadas (latitud y longitud) y devuelve su distancia (en kilómetros).

 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


import math

def haversine_distance(lat1, lon1, lat2, lon2):
 """
 Calcula la distancia del gran círculo entre dos puntos usando la fórmula del semiverseno.
 """
 # Radio promedio de la Tierra (kilómetros)
 R = 6371.0

 # Convertir latitud y longitud de grados a radianes
 phi1, phi2 = math.radians(lat1), math.radians(lat2)
 delta_phi = math.radians(lat2 - lat1)
 delta_lambda = math.radians(lon2 - lon1)

 # Cálculo del semiverseno (Haversine)
 a = math.sin(delta_phi / 2.0)**2 + \
 math.cos(phi1) * math.cos(phi2) * \
 math.sin(delta_lambda / 2.0)**2

 c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))

 # Cálculo de la distancia
 distance = R * c
 return distance

# Distancia desde la Torre de Tokio (35.6586, 139.7454) hasta la Estatua de la Libertad (40.6892, -74.0445)
tokyo = (35.6586, 139.7454)
ny = (40.6892, -74.0445)

dist = haversine_distance(tokyo[0], tokyo[1], ny[0], ny[1])
print(f"Distancia desde la Torre de Tokio a la Estatua de la Libertad: aprox. {dist:.2f} km")

Explicación detallada: Existe otro método usando la ley de los cosenos esféricos, pero cuando la distancia entre los dos puntos es muy corta (por ejemplo, a nivel de metros), tiende a ocurrir una “cancelación catastrófica” (Catastrophic cancellation) en la precisión del cálculo de punto flotante. Debido a que la fórmula del semiverseno utiliza sin^2, tiene una gran ventaja en programación al ser numéricamente estable incluso para distancias minúsculas. Si se requiere aún más precisión, se utilizan las fórmulas de Vincenty, que tratan a la Tierra como un elipsoide.

7. Método de Newton-Raphson (Newton-Raphson Method)

Belleza matemática y resumen

Es un algoritmo de búsqueda de raíces extremadamente poderoso que encuentra repetitivamente la solución (raíz) de la ecuación $f(x) = 0$ utilizando la recta tangente.

$$ x_{n+1} = x_n - \frac{f(x_n)}{f'(x_n)} $$

Utilizando el valor de la función $f(x_n)$ y su pendiente (derivada) $f'(x_n)$ en la posición actual $x_n$, se aproxima una posición más precisa $x_{n+1}$ para buscar a continuación.

flowchart LR Start["Inicio: Adivinar x0 inicial"] --> Eval["Evaluar f(xn) y f'(xn)"] Eval --> Check{"¿Es f(xn) ≈ 0?"} Check -- "Sí" --> Done["Devolver xn como Raíz"] Check -- "No" --> Update["xn+1 = xn - f(xn) / f'(xn)"] Update --> Eval

Aplicaciones en programación

Se utiliza en el renderizado de motores gráficos, detección de colisiones en simulaciones físicas, problemas de optimización, etc. Un caso notable es el “Fast Inverse Square Root” (Cálculo rápido de la raíz cuadrada inversa) incrustado en el código fuente del legendario juego de disparos en primera persona (FPS) “Quake III Arena”. Fue un truco donde el método de Newton se aplicó solo una vez para calcular $1/\sqrt{x}$ de forma asombrosamente rápida, siendo indispensable para la normalización de vectores.

Ejemplo de implementación (C++)

Aquí mostraremos un ejemplo estándar y comprensible del cálculo de la raíz cuadrada $\sqrt{N}$ (es decir, resolviendo $x^2 - N = 0$) con el método de Newton. Será $f(x) = x^2 - N$ y $f'(x) = 2x$.

 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


#include <iostream>
#include <cmath>

double newton_sqrt(double N, double tolerance = 1e-7) {
 if (N < 0) return NAN; // La raíz cuadrada de un número negativo es NaN
 if (N == 0) return 0;

 // Valor inicial estimado (comienza con N mismo)
 double x = N;

 while (true) {
 // Calcular la siguiente suposición: x_new = x - (x^2 - N) / (2x) = (x + N/x) / 2
 double x_new = 0.5 * (x + N / x);

 // Si el cambio es menor que el error permitido (tolerancia), se considera que ha convergido
 if (std::abs(x - x_new) < tolerance) {
 break;
 }
 x = x_new;
 }

 return x;
}

int main() {
 double number = 612.0;
 std::cout << "Square root of " << number << " is: " << newton_sqrt(number) << "\n";
 return 0;
}

Explicación detallada: El mayor atractivo del método de Newton es su “convergencia cuadrática” (Quadratic convergence) si se dan las condiciones. Esto significa que el número de dígitos correctos se duplica aproximadamente con cada iteración, una velocidad de convergencia asombrosa. Considerando que la búsqueda binaria (Binary search) tiene una convergencia lineal, queda claro lo poderosa que es la información proporcionada por la derivada (pequeña pendiente). En el truco de “Quake III”, se logró una precisión increíble al determinar el valor inicial para el método de Newton utilizando el número mágico de operaciones a nivel de bits 0x5f3759df hackeando la estructura del punto flotante de IEEE 754.

8. Curvas de Bézier (Bézier Curves)

Belleza matemática y resumen

Es una ecuación paramétrica que define curvas suaves usando múltiples puntos de control (Control Points). La curva de Bézier cúbica (Cubic Bézier Curve) más comúnmente utilizada tiene 4 puntos $P_0, P_1, P_2, P_3$, y determina las coordenadas $B(t)$ sobre la curva mediante un parámetro $t \ (0 \le t \le 1)$.

$$ B(t) = (1-t)^3 P_0 + 3(1-t)^2 t P_1 + 3(1-t) t^2 P_2 + t^3 P_3 $$

Aplicaciones en programación

Las curvas de Bézier son la base de los gráficos por computadora. Se utilizan en herramientas de dibujo vectorial como Adobe Illustrator, en la renderización de fuentes (TrueType y OpenType), en las funciones de aceleración (easing) para transiciones y animaciones con CSS cubic-bezier(), y en el control de rutas de cámara en videojuegos, es decir, en cualquier momento que se dibujen mediante programa “movimientos o formas suaves”.

Ejemplo de implementación (Python)

Este es el código que genera un conjunto de puntos sobre una curva de Bézier cúbica a partir de 4 puntos de control.

 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


def cubic_bezier(p0, p1, p2, p3, steps=10):
 """
 Genera una lista de coordenadas en una curva de Bézier cúbica.
 p0, p1, p2, p3 son tuplas (x, y).
 steps indica en cuántos segmentos se divide la curva.
 """
 curve_points = []

 for i in range(steps + 1):
 # El parámetro t varía entre 0.0 y 1.0
 t = i / steps

 # Cálculo de los coeficientes que componen la ecuación
 u = 1 - t
 tt = t * t
 uu = u * u
 uuu = uu * u
 ttt = tt * t

 # Calcular las coordenadas x e y para cada punto respectivo
 x = (uuu * p0[0]) + \
 (3 * uu * t * p1[0]) + \
 (3 * u * tt * p2[0]) + \
 (ttt * p3[0])

 y = (uuu * p0[1]) + \
 (3 * uu * t * p1[1]) + \
 (3 * u * tt * p2[1]) + \
 (ttt * p3[1])

 curve_points.append((x, y))

 return curve_points

# Punto de inicio, punto de control 1, punto de control 2, punto final
p0 = (0, 0)
p1 = (5, 10)
p2 = (15, 10)
p3 = (20, 0)

points = cubic_bezier(p0, p1, p2, p3, steps=5)
for i, pt in enumerate(points):
 print(f"t={i/5:.1f} -> Point({pt[0]:.2f}, {pt[1]:.2f})")

Explicación detallada: Esta fórmula es el desarrollo del “algoritmo de De Casteljau” (De Casteljau’s algorithm), que aplica repetidamente interpolaciones lineales (Lerp: Linear Interpolation). Encuentra la solución directa usando cálculos polinomiales (polinomios de Bernstein). En programación, una curva se aproxima dibujándola como una colección de infinitas “rectas diminutas”. Por lo tanto, ajustar la resolución (steps) de $t$ permite controlar el equilibrio entre el rendimiento y la calidad del dibujo.

9. Función Sigmoide (Sigmoid Function)

Belleza matemática y resumen

Es una función en forma de S suave que comprime siempre cualquier entrada de número real $x \ ( -\infty < x < \infty )$ en un valor entre $0$ y $1$.

$$ \sigma(x) = \frac{1}{1 + e^{-x}} $$

Aplicaciones en programación

Históricamente, desempeñó un papel muy importante como “función de activación” (Activation Function) en regresión logística y redes neuronales (Deep Learning o aprendizaje profundo). Su mayor ventaja es que su salida está comprendida en el rango de 0 a 1, lo que permite que el resultado se interprete como una “probabilidad”.

graph LR X1["Entrada x1"] -->|Peso w1| Sum["Suma: Σ(wi*xi) + b"] X2["Entrada x2"] -->|Peso w2| Sum Sum --> Act["Función Sigmoide: σ(x)"] Act --> Out["Probabilidad de Salida (0 a 1)"]

Ejemplo de implementación (Python)

Este código aplica la función sigmoide a una matriz de entrada (tensor).

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


import math

def sigmoid(x):
 """Cálculo sigmoide para un solo valor"""
 # A menudo se restringe el valor de entrada para evitar el desbordamiento de math.exp(-x)
 # Implementación estándar simplificada
 if x >= 0:
 return 1.0 / (1.0 + math.exp(-x))
 else:
 # Prevención de desbordamiento cuando x es un valor negativo grande
 return math.exp(x) / (1.0 + math.exp(x))

def apply_sigmoid(array):
 """Aplica la función sigmoide a todos los elementos en la matriz"""
 return [sigmoid(x) for x in array]

# Datos brutos de la capa de salida de una red neuronal (logits)
logits = [-5.0, -1.0, 0.0, 1.0, 5.0]
probabilities = apply_sigmoid(logits)

for val, prob in zip(logits, probabilities):
 print(f"Input: {val:4.1f} -> Probability: {prob:.4f}")

Explicación detallada: En el código anterior, la bifurcación basada en x >= 0 es para prevenir el “desbordamiento” (overflow), un problema específico en programación. Se trata de una técnica de cálculo numérico para evitar que el programa se bloquee (o devuelva Inf) al intentar calcular, por ejemplo, $e^{1000}$ cuando $x = -1000$. En la actualidad, la ReLU ($f(x) = \max(0, x)$) es la función principal en las capas ocultas del Deep Learning debido a la velocidad de cálculo y el problema del desvanecimiento del gradiente, pero la función sigmoide todavía mantiene una posición firme en las capas de salida para la clasificación binaria.

10. Distancia Euclidiana y Teorema de Pitágoras (Euclidean Distance & Pythagorean Theorem)

Belleza matemática y resumen

Es la base de la geometría desde la antigua Grecia y una fórmula que define la distancia en línea recta entre dos puntos en un espacio de $n$ dimensiones. En un espacio de 2 dimensiones, es el propio Teorema de Pitágoras ($a^2 + b^2 = c^2$).

La distancia Euclidiana $d$ entre el punto $P(x_1, y_1, z_1)$ y $Q(x_2, y_2, z_2)$ en un espacio tridimensional se expresa de la siguiente manera:

$$ d = \sqrt{(x_2-x_1)^2 + (y_2-y_1)^2 + (z_2-z_1)^2} $$

Aplicaciones en programación

Es el cálculo central de cualquier desarrollo de juegos, motor de físicas y algoritmos de “K-vecinos más cercanos” (K-Nearest Neighbors) o de agrupamiento (K-Means) en aprendizaje automático. En los videojuegos, se calcula millones de veces por frame para tareas como la detección de colisiones entre personajes (Bounding Circle / Sphere Collision).

Ejemplo de implementación (C++)

Aquí se muestra código optimizado para determinar si dos círculos (esferas) están colisionando.

 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


#include <iostream>
#include <cmath>

struct Circle {
 double x, y; // Coordenadas del centro
 double radius; // Radio
};

// Función que determina si dos círculos están chocando
bool isColliding(const Circle& a, const Circle& b) {
 // Diferencia (delta) de las coordenadas x e y
 double dx = b.x - a.x;
 double dy = b.y - a.y;

 // Calcular el "cuadrado" de la distancia
 double distanceSquared = (dx * dx) + (dy * dy);

 // Calcular el "cuadrado" de la suma de los radios
 double radiiSum = a.radius + b.radius;
 double radiiSumSquared = radiiSum * radiiSum;

 // Comparar el cuadrado de la distancia con el cuadrado de la suma de los radios
 return distanceSquared <= radiiSumSquared;
}

int main() {
 Circle player = {0.0, 0.0, 5.0};
 Circle enemy1 = {8.0, 0.0, 4.0}; // Distancia 8, suma de radios 9 -> Colisión
 Circle enemy2 = {10.0, 10.0, 2.0}; // Distancia aprox 14.1, suma de radios 7 -> No colisión

 std::cout << "Collision with enemy1: " << (isColliding(player, enemy1) ? "Yes" : "No") << "\n";
 std::cout << "Collision with enemy2: " << (isColliding(player, enemy2) ? "Yes" : "No") << "\n";

 return 0;
}

Explicación detallada: Si se calcula de acuerdo con la fórmula matemática exacta, es necesario tomar la raíz cuadrada $\sqrt{\cdot}$ al final. Sin embargo, en programación, llamar a la función sqrt() es una operación muy pesada para la CPU (consume muchos ciclos de reloj). Por lo tanto, si el objetivo es simplemente comparar distancias, es una práctica común en la programación de videojuegos comparar ambos lados mientras aún están elevados al cuadrado (distanceSquared <= radiiSumSquared). De esta manera, aprovechar las propiedades de igualdades y desigualdades matemáticas para optimizar y reducir la carga de cálculo es uno de los encantos del diseño de algoritmos.

Conclusión

¿Qué te ha parecido? Desde la identidad de Euler hasta el teorema de Pitágoras, estas 10 fórmulas no son simplemente conceptos teóricos que se encuentran en los libros de texto. En el fondo del código que escribimos normalmente, laten como el “corazón” que comprime los datos, permite predecir los modelos de aprendizaje automático, dibuja animaciones suaves y hace posibles búsquedas rápidas.

Comprender los fundamentos matemáticos no es para quedarse siendo solo un codificador que simplemente llama a bibliotecas existentes (como math.sin o numpy.fft), sino que es indispensable para dar el salto a convertirse en un ingeniero capaz de comprender la estructura interna y superar sus límites. La próxima vez que escribas código, trata de imaginar por un momento qué hermosa fórmula matemática está funcionando silenciosamente por detrás.

Happy Coding and Math!

Límites de la factorización de números primos y explicación de la notación Big O (O) de la complejidad temporal

Fri, 11 Sep 2026 23:00:00 +0900

Introducción: ¿Por qué la factorización de números primos es “difícil”?

En la sociedad de Internet actual, la razón por la que podemos disfrutar de las compras en línea y el intercambio de información confidencial con tranquilidad es la existencia de la “tecnología criptográfica”. Y el fundamento que sustenta la seguridad de esta tecnología criptográfica (especialmente el cifrado RSA, que se usa ampliamente) es el hecho matemático de que “la factorización de enteros enormes en números primos es extremadamente difícil”.

A primera vista, la factorización de números primos puede parecer una tarea simple de “simplemente descomponer un número en una multiplicación de números primos”, pero a medida que aumenta el número de dígitos, se transforma en un problema sumamente difícil que ni las supercomputadoras más rápidas del mundo podrían resolver incluso si estuvieran funcionando durante décadas o siglos. La factorización de números primos que solemos aprender en la escuela es, en el mejor de los casos, la simple tarea de dividir por $2$, $3$ o $5$, pero frente al producto de números primos desconocidos de cientos de dígitos, ese enfoque simple colapsa por completo.

En este artículo, comenzando desde el concepto de “complejidad temporal (notación Big O: $\mathcal{O}$)”, que es la base de las ciencias de la información y la computación, explicaremos matemática y detalladamente cuánto tiempo de cálculo requieren varios algoritmos para resolver la factorización de números primos (división por tentativa, algoritmo $\rho$ de Pollard, criba general del cuerpo de números, etc.). Luego, desentrañaremos por qué la factorización en números primos de números gigantescos es prácticamente imposible para las computadoras clásicas, cómo esto protege nuestra información y privacidad, e incluso cómo las computadoras cuánticas cambiarán esta premisa.

Definición estricta de complejidad temporal y notación Big O ($\mathcal{O}$)

Al evaluar el rendimiento y la eficiencia de un algoritmo, no basta con simplemente medir “el tiempo de ejecución del programa (en segundos)”. Esto se debe a que el tiempo de ejecución depende en gran medida del rendimiento de la computadora utilizada (como la frecuencia del reloj de la CPU y la velocidad de la memoria), el lenguaje de programación y la optimización del compilador.

Por lo tanto, la complejidad temporal (Time Complexity) se utiliza como una métrica de evaluación universal independiente del hardware y el entorno, y la notación utilizada para expresarla es la notación Big O (Big-O Notation). La notación Big O es una notación matemática que expresa cómo el tiempo de ejecución (o el número de pasos de ejecución) de un algoritmo aumenta en relación con el tamaño de los datos de entrada $N$ (la tasa de crecimiento asintótico) cuando $N$ se vuelve muy grande.

Definición matemática de la notación asintótica

En ciencias de la computación, para las funciones $f(n)$ y $g(n)$, decir que $f(n) = \mathcal{O}(g(n))$ se define matemáticamente de la siguiente manera:

$$ \exists c > 0, \exists n_0 > 0 \text{ s.t. } \forall n \ge n_0, 0 \le f(n) \le c \cdot g(n) $$

Esto significa que “cuando el tamaño de entrada $n$ es lo suficientemente grande ($n \ge n_0$), el crecimiento de la función $f(n)$ está acotado superiormente por un múltiplo constante de $g(n)$”. En otras palabras, indica un “límite superior (Upper Bound)” de que el tiempo de procesamiento del algoritmo, incluso en el peor de los casos, estará dentro de un múltiplo constante de $g(n)$.

Del mismo modo, existen notaciones como $\Omega$ (Big-Omega) para indicar un límite inferior, y $\Theta$ (Big-Theta) para los casos en que los límites superior e inferior coinciden, pero en general, al discutir la complejidad temporal del peor caso de un algoritmo, la notación $\mathcal{O}$ es la que se usa con más frecuencia.

Clases representativas de complejidad temporal

Existen varias clases representativas de complejidad temporal. Veámoslas en orden desde el tiempo de ejecución más corto (más eficiente).

$\mathcal{O}(1)$ : Tiempo constante (Constant time) Es un algoritmo cuyo tiempo de ejecución no cambia por mucho que aumente el tamaño de entrada $N$. Ejemplos de esto incluyen obtener un valor especificando el índice de un arreglo o buscar en una tabla hash (en el caso ideal).
$\mathcal{O}(\log N)$ : Tiempo logarítmico (Logarithmic time) Es un algoritmo altamente eficiente donde, incluso si el tamaño de la entrada se duplica, el tiempo de ejecución solo aumenta en una constante. La “búsqueda binaria (Binary Search)”, que busca un valor objetivo en un arreglo ordenado, es un ejemplo representativo. Incluso con 1,000 millones de datos, el objetivo se puede encontrar con solo unas 30 comparaciones.
$\mathcal{O}(N)$ : Tiempo lineal (Linear time) El tiempo de ejecución aumenta proporcionalmente al tamaño de la entrada. Si los datos se multiplican por 10, el tiempo también se multiplica por 10. La “búsqueda lineal”, que verifica todos los elementos de un arreglo uno por uno, pertenece a esta categoría.
$\mathcal{O}(N \log N)$ : Tiempo cuasilineal (Linearithmic time) Es un poco más lento que $\mathcal{O}(N)$, pero entra en la categoría eficiente. Muchos de los algoritmos de ordenamiento rápido prácticos, como el ordenamiento por mezcla (Merge Sort) y el ordenamiento rápido (Quick Sort, en su complejidad promedio), tienen esta complejidad temporal.
$\mathcal{O}(N^2)$ : Tiempo polinómico / Tiempo cuadrático (Quadratic time) Cuando el tamaño de la entrada se duplica, el tiempo de ejecución se cuadruplica; si se multiplica por 10, aumenta 100 veces. Los procesamientos simples que usan bucles anidados, el ordenamiento de burbuja (Bubble Sort) y el ordenamiento por inserción (Insertion Sort) caen en esta categoría. Cuando la cantidad de datos supera las decenas de miles, el procesamiento lleva mucho tiempo. Las complejidades temporales expresadas en la forma $\mathcal{O}(N^k)$ se denominan colectivamente tiempo polinómico (Polynomial time).
$\mathcal{O}(2^N)$ : Tiempo exponencial (Exponential time) Un simple aumento de 1 en el tamaño de la entrada duplica el tiempo de ejecución. Es extremadamente ineficiente, y con solo que $N$ llegue a 40 o 50, incluso las computadoras más avanzadas no podrán finalizar el cálculo en un tiempo realista. La búsqueda exhaustiva del problema de la mochila o las soluciones simples para el problema del viajante de comercio pertenecen a esta categoría.
$\mathcal{O}(N!)$ : Tiempo factorial (Factorial time) Aumenta aún más rápido que $\mathcal{O}(2^N)$. Un algoritmo de este tipo probaría todas las permutaciones en el problema del viajante de comercio.

El siguiente diagrama Mermaid es una comparación esquemática de la tasa de crecimiento del tiempo de ejecución (número de pasos) de cada complejidad temporal con respecto al aumento de $N$.

graph TD classDef poly fill:#a8e6cf,stroke:#333,stroke-width:2px; classDef subexp fill:#ffd3b6,stroke:#333,stroke-width:2px; classDef exp fill:#ffaaa5,stroke:#333,stroke-width:2px; Poly["Tiempo Polinómico O(n^k)"]:::poly SubExp["Tiempo Subexponencial L_n"]:::subexp Exp["Tiempo Exponencial O(2^n)"]:::exp GNFS["Criba General del Cuerpo de Números (GNFS)"]:::subexp Pollard["Algoritmo rho de Pollard"]:::exp Trial["División por Tentativa"]:::exp Easy["Factible"]:::poly Hard["Intratable"]:::exp Poly --- Easy Exp --- Hard Trial --> Exp Pollard --> Exp GNFS --> SubExp Poly -.-> SubExp SubExp -.-> Exp

Espero que haya comprendido cuán importante es la diferencia en la complejidad temporal a la hora de elegir un algoritmo. En criptografía, garantizamos la seguridad utilizando intencionalmente problemas que requieren este “tiempo exponencial” o “complejidad temporal cercana a este” (es decir, problemas que no se pueden resolver fácilmente).

El mecanismo del cifrado RSA y el problema de la factorización de números primos

Para comprender por qué es importante la factorización en números primos, repasemos brevemente cómo funciona el cifrado RSA. El cifrado RSA es un sistema criptográfico de clave pública desarrollado en 1977 por Ronald Rivest, Adi Shamir y Leonard Adleman.

Pasos para la generación de claves

Se eligen aleatoriamente dos números primos muy grandes, $p$ y $q$. (Por ejemplo, de 1024 bits de longitud cada uno).
Se multiplican para calcular $N = p \times q$. Este $N$ se hace público al mundo entero como parte de la clave pública. (Tendrá una longitud de 2048 bits).
Se calcula la función indicatriz de Euler $\phi(N) = (p-1)(q-1)$.
Se elige un número entero $e$ que sea coprimo con $\phi(N)$, y esto también se convierte en la clave pública.
Se calcula un $d$ (clave privada) de tal manera que $e \times d \equiv 1 \pmod{\phi(N)}$.

Aquí, lo extremadamente importante es el hecho de que “para descifrar el cifrado es necesaria la clave privada $d$, para calcular $d$ es necesario $\phi(N)$, y para calcular $\phi(N)$, el número $N$ debe ser factorizado en $p$ y $q$”.

La multiplicación de números primos enormes $p \times q$ se realiza en un instante, pero es desesperadamente difícil encontrar (factorizar) los números primos originales $p$ y $q$ a partir del resultado $N$. Esta propiedad de “función unidireccional (One-way function)” es precisamente el corazón del cifrado RSA.

Aquí hay un punto muy importante a tener en cuenta. El “tamaño de entrada $n$” en el problema de la factorización de números primos no es el tamaño del número $N$ en sí, sino “el número de bits necesarios para representar el número $N$”. Si el número de dígitos de la representación binaria del entero $N$ es $n$, entonces $n \approx \log_2 N$. Es decir, la complejidad del algoritmo debe evaluarse en relación con $n = \log_2 N$ (o $\ln N$), no con $N$.

Historia de los algoritmos de factorización de números primos y su complejidad temporal

A partir de aquí, explicaremos en detalle los mecanismos y complejidades de varios algoritmos para descomponer un número compuesto dado $N$ en el producto de números primos. Esta es también la historia de cómo la humanidad ha desafiado los límites de la factorización de números primos.

1. División por tentativa (Trial Division)

El algoritmo más intuitivo y primitivo es la “división por tentativa”. Es un método que intenta dividir $N$ por números primos en ordern, comenzando desde $2$.

Descripción general del algoritmo

Se basa en la propiedad de que los factores primos de $N$ nunca superarán $\sqrt{N}$ (dado que $\sqrt{N} \times \sqrt{N} = N$, si hay un factor primo mayor que eso, necesariamente estará emparejado con un factor primo menor o igual a $\sqrt{N}$). Por lo tanto, se verifica si es divisible por todos los números (o números primos) hasta $2, 3, 5, 7, \dots, \lfloor\sqrt{N}\rfloor$.

Evaluación de la complejidad temporal

En el peor de los casos (como cuando $N$ es el producto de dos números primos enormes), es necesario realizar divisiones hasta $\sqrt{N}$. Como se mencionó anteriormente, dado que el tamaño de entrada $n$ es $n = \log_2 N$, se puede expresar como $N = 2^n$. Por lo tanto, el número de pasos de cálculo es, como máximo, proporcional a lo siguiente:

$$ \sqrt{N} = \sqrt{2^n} = (2^n)^{1/2} = 2^{n/2} $$

Esto significa que la complejidad temporal es de $\mathcal{O}(2^{n/2})$ con respecto a la longitud en bits $n$. En otras palabras, la división por tentativa es un “algoritmo de tiempo puramente exponencial (Exponential time)” con respecto a $n$. Por cada aumento de 1 bit en el número de dígitos (el número se duplica), el tiempo de cálculo se multiplica por aproximadamente $\sqrt{2} \approx 1.414$. Si $N$ es un número que supera los 1024 bits (unos 300 dígitos en decimal), el cálculo no terminaría ni siquiera utilizando una cantidad de tiempo equivalente a la edad del universo.

2. Método de factorización de Fermat (Fermat’s Factorization Method)

Este método fue ideado por el matemático Pierre de Fermat en el siglo XVII. Dado un número compuesto impar $N$, intenta expresar $N$ como la diferencia de dos cuadrados.

$$ N = x^2 - y^2 = (x - y)(x + y) $$

Si se pueden encontrar tales $x$ e $y$, entonces $a = x - y$ y $b = x + y$ serán los factores de $N$. El algoritmo implica incrementar $x$ gradualmente a partir de $\lceil \sqrt{N} \rceil$ y verificar si $x^2 - N$ es un cuadrado perfecto (el cuadrado de algún entero $y$). Este método funciona de manera extremadamente rápida cuando los dos factores primos $p$ y $q$ tienen valores muy cercanos. Sin embargo, en un caso general (cuando $p$ y $q$ toman valores que están separados al azar), en última instancia requerirá un tiempo exponencial similar al de la división por tentativa.

3. Algoritmo $\rho$ de Pollard (Pollard’s rho algorithm)

Uno de los algoritmos ideados para superar los límites de la división por tentativa fue el “Algoritmo $\rho$ (rho) de Pollard”, presentado por John Pollard en 1975.

Descripción general del algoritmo

Este método aplica el concepto probabilístico conocido como la “Paradoja del cumpleaños (Birthday Paradox)” y la periodicidad de las secuencias de números pseudoaleatorios (se llama así porque esta forma se asemeja a la letra griega $\rho$).

Usando una función generadora de números pseudoaleatorios $f(x) = (x^2 + 1) \pmod N$, genera una secuencia de números y encuentra dos valores $x_i \equiv x_j \pmod p$ (donde $p$ es un factor primo desconocido de $N$) dentro de la secuencia. En este momento, dado que $x_i - x_j$ será un múltiplo de $p$, se puede extraer $p$ (es decir, el factor primo de $N$) con alta probabilidad calculando el máximo común divisor $\gcd(|x_i - x_j|, N)$. Al combinarlo con el algoritmo de detección de ciclos de Robert Floyd (el algoritmo de la liebre y la tortuga), los cálculos se pueden realizar de manera eficiente manteniendo el uso de memoria en $\mathcal{O}(1)$.

Evaluación de la complejidad temporal

Se sabe que el número de pasos necesarios para que el algoritmo $\rho$ de Pollard encuentre un factor primo $p$ es aproximadamente $\mathcal{O}(\sqrt{p})$. En el peor de los casos (cuando $N$ es el producto de dos números primos del mismo tamaño $p$ y $q$, resultando en $p \approx \sqrt{N}$), la complejidad es $\mathcal{O}(N^{1/4})$.

Expresado en términos del tamaño de entrada $n = \log_2 N$:

$$ N^{1/4} = (2^n)^{1/4} = 2^{n/4} $$

Por lo tanto, la complejidad temporal es $\mathcal{O}(2^{n/4})$. Es drásticamente más rápido en comparación con el $\mathcal{O}(2^{n/2})$ de la división por tentativa, y en la práctica es muy poderoso para la factorización de números de tamaño mediano (decenas de dígitos). Sin embargo, todavía no ha superado la barrera del “tiempo exponencial” con respecto a la longitud en bits $n$, y es inútil contra números gigantescos de 2048 bits (alrededor de 600 dígitos en decimal) como los que se utilizan en el cifrado RSA.

4. Criba cuadrática de polinomios múltiples (MPQS: Multiple Polynomial Quadratic Sieve)

A principios de la década de 1980, Carl Pomerance ideó la “Criba cuadrática (Quadratic Sieve: QS)”. Esta es una extensión del concepto de “diferencia de cuadrados” de Fermat. Mientras que el método de Fermat buscaba directamente $x^2 - y^2 = N$, la criba cuadrática busca condiciones mucho más laxas.

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

$$ x \not\equiv \pm y \pmod N $$

Si podemos encontrar un par de $x$ e $y$ así, $x^2 - y^2 = (x - y)(x + y)$ será un múltiplo de $N$. Por lo tanto, calculando $\gcd(x - y, N)$ o $\gcd(x + y, N)$, podemos obtener un factor primo no trivial de $N$.

En la criba cuadrática, encontramos una gran cantidad de $x$ tales que $x^2 \pmod N$ sea un número compuesto únicamente por pequeños factores primos (esto se denomina número $B$-liso), y organizamos los resultados de su factorización en forma de matriz (un sistema de ecuaciones lineales sobre el cuerpo finito $\mathbb{F}_2$). Luego, usando la eliminación gaussiana u otros métodos, multiplicamos múltiples relaciones matemáticas para ajustar el lado derecho y que se convierta en un cuadrado perfecto (haciendo pares los exponentes de cada factor primo), construyendo así $x^2 \equiv y^2 \pmod N$.

La criba cuadrática fue el algoritmo más rápido del mundo hasta la aparición de la criba general del cuerpo de números, y en la actualidad sigue siendo considerado el más rápido para factorizar números de menos de 100 dígitos.

5. Profundización en la Criba General del Cuerpo de Números (General Number Field Sieve: GNFS)

Actualmente, se considera que el algoritmo “más rápido del mundo” para la factorización en números primos de enteros gigantes que superan los 100 dígitos es la Criba General del Cuerpo de Números (GNFS). Fue ideado a finales de la década de 1980 y es un algoritmo avanzado que desarrolla aún más la criba cuadrática, utilizando resultados profundos de la teoría algebraica de números (cuerpos de números).

En los ataques al cifrado RSA (factorización de números primos a partir de una clave pública), siempre es este GNFS el que sigue rompiendo récords mundiales. En 2020, hubo un informe de una factorización exitosa de un número compuesto de 829 bits (250 dígitos) (RSA-250), pero esto requirió la operación paralela a gran escala de miles de computadoras durante un largo período.

Estructura matemática del algoritmo

Aunque GNFS es extremadamente complejo, a grandes rasgos procede en los siguientes pasos:

Selección del polinomio (Polynomial Selection): Para $N$, elegimos un entero $m$ y un polinomio irreducible $f(X)$ con coeficientes pequeños de tal manera que $f(m) \equiv 0 \pmod N$. Esto define el anillo de enteros $\mathbb{Z}[\alpha]$ de un cuerpo algebraico (cuerpo de números) que adjunta la raíz $\alpha$ de $f(X)$.
Criba (Sieving): Buscamos simultáneamente números lisos (Smooth) en los “dos mundos diferentes”: el anillo de enteros $\mathbb{Z}$ sobre el cuerpo de los números racionales, y el anillo de enteros $\mathbb{Z}[\alpha]$ sobre el cuerpo algebraico. Específicamente, buscamos una gran cantidad de pares $(a, b)$ de modo que las normas de un entero racional $a - bm$ y de un entero algebraico $a - b\alpha$ se factoricen completamente sobre un conjunto de números primos pequeños predefinidos (Base de Factores: Factor Base).
Reducción de la matriz (Matrix Reduction): Representamos la gran cantidad de pares lisos encontrados como una matriz (una matriz dispersa gigante). Encontramos el espacio de soluciones utilizando el algoritmo de Lanczos (como el método de Lanczos por bloques) sobre el cuerpo finito $\mathbb{F}_2$. No es raro que esta matriz abarque millones de filas $\times$ millones de columnas.
Cálculo de la raíz cuadrada (Square Root): A partir de la solución de la matriz, creamos un número cuadrado gigante en cada uno de los “dos mundos diferentes”, y finalmente derivamos la relación $X^2 \equiv Y^2 \pmod N$. Luego, calculamos $\gcd(X-Y, N)$ para obtener los factores primos.

Complejidad temporal de la criba general del cuerpo de números: Tiempo subexponencial (Sub-exponential time)

El mayor logro de GNFS es que redujo la complejidad temporal de la factorización de números primos de “tiempo puramente exponencial” a “tiempo subexponencial (Sub-exponential time)”. La complejidad temporal asintótica de GNFS se expresa de la siguiente manera usando una notación especial llamada notación L (L-notation).

$$ L_N[\gamma, c] = \exp\left( (c + o(1)) (\ln N)^\gamma (\ln \ln N)^{1-\gamma} \right) $$

Donde $N$ es el número a factorizar y $\ln$ es el logaritmo natural. $\gamma$ es un parámetro que toma un valor de $0 \le \gamma \le 1$ e indica el “grado” de complejidad del algoritmo.

Cuando $\gamma = 0$, $L_N[0, c]$ se convierte en $(\ln N)^c$, lo que significa tiempo polinómico $\mathcal{O}(n^c)$. (Eficiente)
Cuando $\gamma = 1$, $L_N[1, c]$ se convierte en $e^{c \ln N} = N^c$, lo que significa tiempo exponencial $\mathcal{O}(2^{cn})$. (Ineficiente)

En el caso de GNFS, este parámetro es el siguiente:

$$ L_N\left[\frac{1}{3}, \left(\frac{64}{9}\right)^{1/3}\right] = e^{\left(\sqrt[3]{\frac{64}{9}} + o(1)\right) (\ln N)^{1/3} (\ln \ln N)^{2/3}} $$

En esta fórmula, la constante $c = (64/9)^{1/3} \approx 1.923$. Reescribiéndolo en términos del tamaño de entrada $n \approx \ln N$ (proporcional a la longitud en bits), la complejidad se comporta aproximadamente de la siguiente manera:

$$ \mathcal{O}\left( \exp\left( 1.923 \cdot n^{1/3} (\ln n)^{2/3} \right) \right) $$

Podemos ver que la parte exponencial depende de $n^{1/3}$ (la raíz cúbica de $n$), en lugar de la primera potencia de $n$. Mientras que el algoritmo $\rho$ de Pollard era de $\mathcal{O}(2^{n/4})$, es decir, $\mathcal{O}(\exp(c \cdot n^1))$, el grado de $n$ en GNFS se ha reducido a $1/3$. Esto significa que, aunque no alcanza el tiempo polinómico ($\gamma=0$), la complejidad temporal aumenta mucho más lentamente que en el tiempo puramente exponencial ($\gamma=1$). Esta es la razón por la que se le llama “tiempo subexponencial”.

Los límites de la criptografía moderna y la computación cuántica

Como hemos visto hasta ahora, la humanidad ha movilizado su sabiduría matemática para continuar desafiando las barreras de la factorización de números primos mediante la evolución de algoritmos, desde la división por tentativa hasta el GNFS. Sin embargo, incluso con el GNFS, la factorización de números primos aún no se puede resolver en “tiempo polinómico” en una computadora clásica.

El problema P vs NP y la posición de la factorización de números primos

El mayor problema sin resolver en la informática es la “hipótesis P = NP”. El problema de la factorización de números primos pertenece a NP (la clase de problemas para los cuales la corrección de una respuesta proporcionada se puede verificar en tiempo polinómico), pero no se ha demostrado que sea NP-completo (la clase de problemas más difíciles dentro de NP). Además, tampoco está resuelto si pertenece a P (la clase de problemas que se pueden resolver en tiempo polinómico) (es decir, si existe un algoritmo de tiempo polinómico).

Muchos investigadores conjeturan que la factorización de números primos pertenece a una clase intermedia (NP-intermediate) que no es ni P ni NP-completa. Si se descubriera un algoritmo que resuelva la factorización de números primos en tiempo polinómico en una computadora clásica (por ejemplo, $\mathcal{O}(n^3)$), sería un evento monumental que colapsaría los sistemas criptográficos de todo el mundo; sin embargo, hasta la fecha, no se ha descubierto tal algoritmo. Se estima que descifrar un cifrado RSA de 2048 bits tomaría un tiempo mayor que la edad del universo, incluso asumiendo que las mejoras de rendimiento en computadoras clásicas sigan la Ley de Moore.

Las computadoras cuánticas como “cambiadores de juego”: El algoritmo de Shor

Aunque el cifrado RSA es robusto en las computadoras clásicas, la situación cambiará drásticamente cuando las “computadoras cuánticas”, que operan bajo principios completamente diferentes, se vuelvan viables. El “Algoritmo de Shor (Shor’s algorithm)”, publicado por Peter Shor en 1994, es un algoritmo que puede resolver de manera asombrosa la factorización de números primos en tiempo polinómico $\mathcal{O}(n^3)$ (más estrictamente, alrededor de $\mathcal{O}(n^2 \log n \log \log n)$ en términos de número de puertas cuánticas) aprovechando la transformada cuántica de Fourier.

Verifiquemos la diferencia en la complejidad temporal entre los algoritmos clásicos y cuánticos en el siguiente diagrama Mermaid.

graph LR classDef classical fill:#f9f871,stroke:#333,stroke-width:2px; classDef quantum fill:#00c9a7,stroke:#333,stroke-width:2px; subgraph "Computadoras Clásicas" C1["División por Tentativa: O(2^(n/2))"]:::classical C2["GNFS: Subexponencial L_n(1/3)"]:::classical end subgraph "Computadoras Cuánticas" Q1["Algoritmo de Shor: O(n^3) Polinómico"]:::quantum end C1 --> C2 C2 -. "Límite de la Física Clásica" .-> Q1

En el algoritmo de Shor, el proceso de “búsqueda de período”, que era un cuello de botella en los algoritmos clásicos, se calcula de manera instantánea y paralela mediante la “Transformada Cuántica de Fourier (QFT)” utilizando entrelazamiento y superposición cuántica. Una vez que pueda ejecutarse en una computadora cuántica a escala práctica (con poco ruido y suficientes qubits lógicos), el cifrado RSA de 2048 bits que hoy se considera seguro podría descifrarse por completo en un plazo de unas horas a unos días.

Para prepararse para esta amenaza, criptógrafos de todo el mundo y el NIST (Instituto Nacional de Estándares y Tecnología de EE.UU.) están avanzando rápidamente en los trabajos de estandarización hacia la transición a la “Criptografía Post-Cuántica (PQC: Post-Quantum Cryptography)”, la cual es difícil de descifrar incluso para las computadoras cuánticas. La criptografía basada en retículos (Lattice-based cryptography) es un ejemplo representativo, que basa su seguridad en dificultades matemáticas (como el problema del vector más corto) que son completamente diferentes del problema de la factorización de números primos.

Resumen

En este artículo, comenzando desde los conceptos básicos de la complejidad temporal (notación Big O), hemos profundizado en la evolución de los algoritmos de factorización de números primos y sus límites matemáticos.

La notación Big O ($\mathcal{O}$) es un indicador importante que muestra la tasa de aumento en el número de pasos computacionales con respecto a un aumento en el tamaño de la entrada $n$, y existe un muro enorme, prácticamente insuperable en la práctica, entre el tiempo polinómico y el tiempo exponencial.
La división por tentativa y el algoritmo $\rho$ de Pollard son algoritmos puros de “tiempo exponencial” y son impotentes frente a números gigantescos.
El algoritmo clásico más rápido en la actualidad, la Criba General del Cuerpo de Números (GNFS), logró un “tiempo subexponencial” haciendo pleno uso de la teoría algebraica avanzada de números, pero aun así no alcanza el tiempo polinómico y requiere una cantidad de tiempo astronómica para factorizar números enormes.
El hecho de que “se conjetura fuertemente que no existe ningún algoritmo clásico que resuelva el problema en tiempo polinómico” es exactamente lo que garantiza la seguridad del cifrado RSA y apoya a la sociedad digital moderna.
Sin embargo, con el advenimiento de las computadoras cuánticas y el algoritmo de Shor, la factorización de números primos en tiempo polinómico se ha vuelto teóricamente posible, y la tecnología de cifrado está a punto de dar el salto a la próxima era (criptografía post-cuántica).

El hecho de que un concepto abstracto como la complejidad temporal de un algoritmo esté directamente vinculado a la seguridad de nuestras vidas es uno de los aspectos más fascinantes y emocionantes de la informática y las matemáticas. No deje de seguir de cerca la futura evolución de la tecnología, especialmente las tendencias en el desarrollo de las computadoras cuánticas y los cambios en la tecnología criptográfica.