Qiskit on kenji.blog

Súper introducción a la programación cuántica usando Qiskit

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

1. Introducción

Las computadoras modernas (computadoras clásicas) han cambiado drásticamente nuestras vidas, apoyando todos los aspectos de la sociedad a través de su alta capacidad de cálculo. Sin embargo, para ciertos problemas específicos (por ejemplo, la factorización de números primos gigantescos, la simulación de estructuras moleculares complejas, problemas de optimización, etc.), se sabe que incluso las supercomputadoras más avanzadas de la actualidad necesitarían más tiempo que la edad del universo.

Lo que tiene el potencial de romper estos “límites de las computadoras clásicas” es la computadora cuántica (Quantum Computer). Al aprovechar las extrañas propiedades de la mecánica cuántica (superposición y entrelazamiento cuántico) como recursos de cálculo, se cree que es posible acelerar drásticamente la resolución de problemas específicos.

En este artículo, daremos el primer paso en el mundo de la programación cuántica utilizando Qiskit, el framework de computación cuántica de código abierto proporcionado por IBM. Esta es una guía introductoria muy detallada que explica cuidadosamente desde los fundamentos de la física y las matemáticas, hasta el proceso de escribir código real en Python y ejecutar circuitos cuánticos en un simulador.

2. Fundamentos físicos y matemáticos que sustentan la computación cuántica

Para entender la programación cuántica, primero es necesario comprender los conceptos básicos de la mecánica cuántica. Aquí explicaremos los tres pilares importantes: cúbit, superposición y entrelazamiento cuántico.

2.1 Bit clásico y cúbit (Qubit)

La unidad de información de una computadora clásica es el “bit (Bit)”. Un bit siempre toma uno de los dos estados: 0 o 1.

Por otro lado, la unidad mínima de información en una computadora cuántica se llama cúbit (Qubit: Quantum bit). Los cúbits no solo pueden tomar los estados 0 y 1, sino que también pueden mantener ambos estados simultáneamente.

Matemáticamente, el estado de un cúbit $|\psi\rangle$ se expresa como una combinación lineal (superposición) de los estados base $|0\rangle$ y $|1\rangle$.

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

Aquí, $\alpha$ y $\beta$ son números complejos que representan las amplitudes de probabilidad de observar los estados $|0\rangle$ y $|1\rangle$, respectivamente. Basado en los principios básicos de la mecánica cuántica, dado que la suma de las probabilidades debe ser 1, se cumple la siguiente condición de normalización:

$$ |\alpha|^2 + |\beta|^2 = 1 $$

Es decir, cuando “medimos (observamos)” este cúbit, la probabilidad de obtener $|0\rangle$ es $|\alpha|^2$ y la probabilidad de obtener $|1\rangle$ es $|\beta|^2$. El hecho de que el estado solo se determine probabilísticamente antes de la medición es una diferencia crucial con respecto a los bits clásicos.

graph LR A["Bit clásico (Classical Bit)"] --> B["Estado determinado: 0 o 1"] C["Cúbit (Qubit)"] --> D["Superposición: Ambos 0 y 1"] D --> E["El estado se determina probabilísticamente mediante la medición"]

2.2 Superposición (Superposition)

Como se mencionó anteriormente, el estado en el que se mezclan $|0\rangle$ y $|1\rangle$ se llama superposición (Superposition).

Por ejemplo, cuando un cúbit está en un estado de superposición completamente uniforme, $\alpha = \frac{1}{\sqrt{2}}$ y $\beta = \frac{1}{\sqrt{2}}$.

$$ |\psi\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle $$

Al medir este estado, se observa $|0\rangle$ y $|1\rangle$ con un 50% de probabilidad cada uno. Si tenemos 2 cúbits, podemos crear una superposición de 4 estados: $|00\rangle, |01\rangle, |10\rangle, |11\rangle$. Si tenemos $n$ cúbits, podemos representar $2^n$ estados simultáneamente, y esta es una de las fuentes del poder de procesamiento paralelo de las computadoras cuánticas.

2.3 Entrelazamiento cuántico (Entanglement)

La propiedad más poderosa y misteriosa en la computación cuántica es el entrelazamiento cuántico (Entanglement). Este fenómeno, que Einstein llamó “acción fantasmal a distancia”, es una propiedad donde dos o más cúbits están fuertemente conectados entre sí, y cuando se determina el estado de uno de ellos, el estado del otro se determina instantáneamente, sin importar cuán lejos estén físicamente.

Uno de los estados entrelazados más famosos, el estado $\Phi^+$ de los “estados de Bell (Bell State)”, se expresa de la siguiente manera:

$$ |\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}} $$

3. Puertas lógicas cuánticas (Quantum Logic Gates)

Al igual que las computadoras clásicas realizan cálculos utilizando puertas lógicas como AND, OR y NOT, las computadoras cuánticas manipulan el estado de los cúbits utilizando puertas cuánticas. Dado que los estados cuánticos son vectores, las puertas cuánticas se representan como “matrices unitarias” que actúan sobre esos vectores.

3.1 Puertas de Pauli (Pauli-X, Y, Z)

Las puertas de Pauli son operaciones básicas sobre 1 cúbit.

・Puerta Pauli-X (Puerta NOT) Equivale a la puerta NOT clásica. Invierte $|0\rangle$ a $|1\rangle$, y $|1\rangle$ a $|0\rangle$. (Rotación de 180 grados alrededor del eje X en la esfera de Bloch).

$$ X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} $$

・Puerta Pauli-Y Realiza una rotación de 180 grados alrededor del eje Y. Tiene el efecto de invertir tanto la fase como el bit.

$$ Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} $$

・Puerta Pauli-Z (Puerta de inversión de fase) Mantiene el estado $|0\rangle$ tal como está, e invierte la fase del estado $|1\rangle$ (multiplica por $-1$). (Rotación de 180 grados alrededor del eje Z).

$$ Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} $$

3.2 Puerta de Hadamard (Hadamard Gate)

La puerta de Hadamard (Puerta H) es una puerta extremadamente importante que convierte un estado determinado ($|0\rangle$ o $|1\rangle$) en un estado de superposición.

$$ H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} $$

Al aplicar la puerta H a $|0\rangle$, obtenemos el estado $|+\rangle$, que es un estado de superposición uniforme.

$$ H|0\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle = |+\rangle $$

3.3 Puertas de fase (Phase Gates)

Las puertas de fase generalizan la puerta Z, rotando la fase del estado $|1\rangle$ un ángulo específico $\theta$.

$$ P(\theta) = \begin{pmatrix} 1 & 0 \\ 0 & e^{i\theta} \end{pmatrix} $$

Ejemplos típicos son la puerta S ($\theta = \pi/2$) y la puerta T ($\theta = \pi/4$).

3.4 Puerta CNOT (Controlled-NOT Gate)

La puerta CNOT (Puerta CX) es una puerta que opera entre 2 cúbits y es indispensable para generar entrelazamiento cuántico. Consiste en un “bit de control (Control)” y un “bit objetivo (Target)”.

Solo cuando el bit de control es $|1\rangle$, se aplica una puerta X (operación NOT) al bit objetivo. Si el bit de control es $|0\rangle$, no hace nada.

$$ CNOT = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix} $$

4. Conceptos básicos de Qiskit y configuración del entorno

A partir de aquí, utilizaremos Python y Qiskit en la práctica para escribir un programa cuántico.

4.1 ¿Qué es Qiskit?

Qiskit es un kit de desarrollo de software (SDK) de código abierto para computación cuántica desarrollado por IBM Quantum. Permite construir circuitos cuánticos de forma intuitiva utilizando Python y ejecutarlos en simuladores locales o en hardware cuántico real de IBM a través de la nube.

4.2 Método de instalación

Para utilizar Qiskit, necesitas un entorno de Python. Instala Qiskit y los paquetes relacionados (simuladores y bibliotecas de dibujo) con el siguiente comando.

1

pip install qiskit qiskit-aer qiskit-ibm-runtime matplotlib pylatexenc

4.3 Flujo básico de programación

La programación cuántica utilizando Qiskit procede principalmente en los siguientes pasos.

graph TD A["1. Construcción del circuito (Build)"] --> B["2. Compilación/Transpilación (Compile)"] B --> C["3. Ejecución (Execute)"] C --> D["4. Análisis y visualización de resultados (Analyze)"]

Construcción del circuito: Se crea un objeto QuantumCircuit y se van agregando puertas.
Compilación: Se optimiza el circuito de acuerdo al backend de ejecución (hardware real o simulador).
Ejecución: Se envía el trabajo al backend y se obtienen los resultados.
Análisis: Se grafica un histograma de los resultados de la medición.

5. Práctica: Construcción de un circuito que crea el estado de Bell (Entrelazamiento cuántico)

Intentemos crear el “entrelazamiento cuántico (estado de Bell)” que aprendimos en la teoría, en la práctica con Qiskit. El estado objetivo es $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$.

5.1 Diseño del circuito

Para crear el estado de Bell, seguiremos los siguientes pasos:

Preparar 2 cúbits (el estado inicial de ambos es $|0\rangle$).
Aplicar una puerta de Hadamard (H) al primer cúbit para ponerlo en un estado de superposición.
Aplicar una puerta CNOT utilizando el primer cúbit como “bit de control” y el segundo cúbit como “bit objetivo”.
Realizar una medición (Measure) para leer el resultado.

5.2 Implementación del código en Python/Qiskit

Veamos el código real.

 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


import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit_aer import Aer
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt

# 1. Inicialización del circuito
# Crear un circuito cuántico con 2 cúbits y 2 bits clásicos
qc = QuantumCircuit(2, 2)

# 2. Aplicación de la puerta H
# Aplicar la puerta de Hadamard al cúbit 0 (q0)
qc.h(0)

# 3. Aplicación de la puerta CNOT
# Aplicar CNOT con q0 como bit de control y q1 como bit objetivo
qc.cx(0, 1)

# 4. Medición
# Medir los cúbits 0 y 1 y escribir en los bits clásicos 0 y 1 respectivamente
qc.measure([0, 1], [0, 1])

# Dibujar el diagrama del circuito (usando matplotlib)
# qc.draw('mpl')
print(qc.draw())

Al ejecutar este código, se mostrará el siguiente diagrama de circuito cuántico en arte ASCII en la consola.

1
2
3
4
5
6
7


 ┌───┐ ┌─┐
q_0: ┤ H ├──■──┤M├───
 └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
 └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
 0 1

H representa la puerta de Hadamard, la combinación de ■ y X es la puerta CNOT, y M representa la medición.

5.3 Ejecución en el simulador e interpretación de los resultados

A continuación, ejecutaremos este circuito en el simulador de alto rendimiento Aer de IBM y verificaremos los resultados.

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


# Obtener el backend del simulador Aer
simulator = Aer.get_backend('qasm_simulator')

# Transpilar (optimizar) el circuito para el simulador
compiled_circuit = transpile(qc, simulator)

# Ejecutar el circuito (aquí ejecutamos 1000 disparos)
job = simulator.run(compiled_circuit, shots=1000)

# Obtener los resultados
result = job.result()

# Obtener el recuento de observaciones del estado
counts = result.get_counts(compiled_circuit)
print("\nResultados de medición:", counts)

# Graficar el histograma
# plot_histogram(counts)
# plt.show()

Interpretación de los resultados

La salida en la consola debería verse así: Resultados de medición: {'00': 495, '11': 505} (*Como la probabilidad es aleatoria, los números variarán ligeramente en cada ejecución).

En un entorno de simulación ideal, los resultados de la medición mostrarán 00 y 11 con aproximadamente un 50% de probabilidad cada uno, y 01 y 10 no se observarán en absoluto. Esto coincide perfectamente con la predicción teórica del estado de Bell $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$ que hemos creado. Si el primer cúbit es 0, el segundo siempre será 0, y si es 1, siempre será 1, simulando con precisión este “entrelazamiento cuántico”.

Cabe señalar que al ejecutarlo en una computadora cuántica real (IBM Quantum Hardware), los estados 01 y 10 pueden ser observados ligeramente debido al impacto del ruido (decoherencia cuántica y errores de puerta). Reducir este ruido (corrección de errores cuánticos) es uno de los mayores desafíos en el desarrollo actual de las computadoras cuánticas.

6. Escalando a algoritmos más avanzados

La creación del estado de Bell puede considerarse el “Hello World” de la programación cuántica. Al desarrollarlo aún más, es posible construir poderosos algoritmos que superan a las computadoras clásicas.

6.1 Algoritmo de Deutsch-Jozsa (Deutsch-Jozsa Algorithm)

Este es un problema en el que se determina si una función dada $f(x)$ es una “función constante” (siempre devuelve 0 o siempre devuelve 1 independientemente de la entrada) o una “función equilibrada” (devuelve 0 para la mitad de las entradas y 1 para la otra mitad). En una computadora clásica, en el peor de los casos, se requerirían $2^{n-1} + 1$ evaluaciones de la función, pero utilizando el algoritmo de Deutsch-Jozsa, se puede determinar con solo 1 evaluación utilizando el paralelismo cuántico. Esto muestra el patrón básico de los algoritmos cuánticos, donde se introduce un estado de superposición, se utiliza la interferencia (Interference) para cancelar los estados innecesarios y se amplifica la respuesta deseada.

6.2 Algoritmo de Grover (Grover’s Algorithm)

En el problema de buscar datos específicos en una base de datos de $N$ elementos no ordenados, mientras que un algoritmo clásico requiere un promedio de $N/2$ cálculos, el algoritmo de Grover puede encontrar los datos deseados en $\sqrt{N}$ cálculos. Este algoritmo utiliza una caja negra llamada “oráculo (Oracle)” para invertir la fase de la solución objetivo, y luego realiza una “amplificación de amplitud (Amplitude Amplification)” para aumentar drásticamente la probabilidad de observar la solución deseada.

graph TD A["Inicialización (Superposición de todos los estados)"] --> B["Oráculo (Invierte la fase de la respuesta correcta)"] B --> C["Operador de difusión (Amplificación de amplitud por inversión en torno a la media)"] C --> D{"¿Se alcanzó una probabilidad suficiente?"} D -- "No" --> B D -- "Yes" --> E["Medición"]

7. Conclusión y próximos pasos en el aprendizaje

En este artículo, comenzamos desde conceptos fundamentales de la computación cuántica como la superposición y el entrelazamiento cuántico, y explicamos detalladamente hasta la manipulación de puertas lógicas cuánticas utilizando Qiskit, así como la construcción real, simulación e interpretación de resultados del estado de Bell.

Dado que Qiskit se puede escribir en un lenguaje familiar como Python, es una herramienta poderosa que te permite superar las barreras matemáticas y físicas, y concentrarte en la construcción de algoritmos. Aunque actualmente las computadoras cuánticas están en la era de los dispositivos cuánticos ruidosos de escala intermedia (NISQ: Noisy Intermediate-Scale Quantum), la investigación aplicada está avanzando rápidamente en todo el mundo en muchos campos como el aprendizaje automático cuántico (Quantum Machine Learning), la simulación química (Quantum Chemistry) y la criptografía.

Aprovecha esta oportunidad para construir varios circuitos cuánticos por ti mismo utilizando Qiskit y ejecútalos en procesadores reales de IBM Quantum. Seguramente podrás experimentar con tus propias manos el paradigma computacional del futuro.

Referencias

Documentación oficial de Qiskit
Qiskit Textbook - Texto oficial recomendado para aquellos que deseen profundizar en los antecedentes matemáticos y algorítmicos.
IBM Quantum Learning

¡Bienvenido al mundo cuántico!

Simulé el algoritmo de Shor en Python

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

1. Introducción: La crisis de la criptografía provocada por las computadoras cuánticas

Gran parte de la seguridad en la sociedad de Internet moderna depende de la criptografía de clave pública (especialmente RSA). Cuando enviamos la información de nuestra tarjeta de crédito en compras en línea o intercambiamos datos altamente confidenciales, el contenido de esa comunicación está fuertemente protegido por la criptografía RSA.

La base de la seguridad de la criptografía RSA radica en el hecho matemático de que “la factorización de números enteros enormes es extremadamente difícil para las computadoras clásicas (las PC y supercomputadoras que usamos normalmente)”. Sin embargo, el “Algoritmo de Shor (Shor’s Algorithm)”, publicado por Peter Shor en 1994, socavó esta premisa desde sus cimientos. Se demostró matemáticamente que, si se ejecuta el algoritmo de Shor en una computadora cuántica a gran escala, la factorización de números primos, que le tomaría a una computadora clásica más tiempo que la edad del universo, puede resolverse en solo unos minutos a unas horas.

En este artículo, explicaremos exhaustiva y detalladamente cómo el algoritmo de Shor realiza la factorización de manera rápida, desde su mecanismo matemático hasta la implementación de una simulación concreta utilizando Python y el marco de computación cuántica Qiskit.

2. Cambio dramático en la complejidad computacional: De tiempo exponencial a polinómico

¿Por qué es difícil la factorización? Incluso si utilizamos la “Criba General del Campo de Números (General Number Field Sieve, GNFS)”, conocida como el mejor algoritmo de factorización en computadoras clásicas, su complejidad computacional es subexponencial.

La complejidad temporal para factorizar un número compuesto de $N$ dígitos con métodos clásicos es la siguiente:

$$ O\left(\exp\left( c (\log N)^{1/3} (\log \log N)^{2/3} \right)\right) $$

Por lo tanto, con solo aumentar la longitud de la clave (por ejemplo, a 2048 o 4096 bits), a una computadora clásica le tomará miles o decenas de miles de años descifrarla, un tiempo que no es realista.

Sin embargo, al utilizar el algoritmo de Shor en una computadora cuántica, la complejidad computacional se reduce dramáticamente a tiempo polinómico respecto al número de bits de entrada $\log N$.

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

Esto significa que si se duplica el número de bits, el tiempo de cálculo en una computadora clásica aumentaría astronómicamente, mientras que en una computadora cuántica aumentaría como mucho unas 8 veces. Esta reducción de la clase de complejidad de tiempo exponencial a polinómico (inclusión en la clase BQP) es la verdadera grandeza del algoritmo de Shor.

graph TD A["Aumento del tamaño de entrada (número de bits) N"] --> B{"Elección del algoritmo"} B -->|Clásico: Criba General del Campo de Números| C["Aumento subexponencial O(exp(...))"] B -->|Cuántico: Algoritmo de Shor| D["Tiempo polinómico O((log N)^3)"] C --> E["Miles a miles de millones de años (Indescifrable)"] D --> F["Minutos a horas (Descifrable en tiempo realista)"]

3. Visión general del algoritmo y fundamentos matemáticos

De hecho, el algoritmo de Shor no realiza todo en la computadora cuántica. Está compuesto por una colaboración entre el preprocesamiento y posprocesamiento mediante una computadora clásica y la parte central (algoritmo de búsqueda de período) realizada por la computadora cuántica.

El flujo general del algoritmo es el siguiente:

graph TD A["Entrada: Número compuesto a factorizar N"] --> B["Elegir un número aleatorio a tal que a < N"] B --> C{"gcd(a, N) > 1 ?"} C -- "Sí" --> D["Imprimir factor trivial gcd(a, N) y terminar"] C -- "No" --> E["Encontrar el período r de f(x) = a^x mod N con algoritmo cuántico"] E --> F{"¿r es par y a^(r/2) ≢ -1 mod N ?"} F -- "No" --> B F -- "Sí" --> G["Calcular factores p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N)"] G --> H["Salida: p, q"]

Reducción del problema de factorización al problema de búsqueda de período

La genialidad de Shor consistió en transformar el “problema de factorización” en el “problema de búsqueda de período (Order Finding Problem)”.

Consideremos un entero $N$ (el número que queremos factorizar) y un entero $a$ coprimo con $N$ ($1 < a < N$). Definimos la siguiente función exponencial modular:

$$ f(x) = a^x \bmod N $$

Esta función tiene un cierto período $r$. Es decir, para cualquier $x$, se cumple que $f(x+r) = f(x)$. Especialmente cuando $x=0$,

$$ a^r \equiv 1 \pmod N $$

El número entero positivo más pequeño $r$ que cumple esto se llama el “orden (Order) de $a$ módulo $N$”. Si podemos encontrar este período $r$, podemos deducir los factores primos de la siguiente manera.

Transformando la ecuación,

$$ a^r - 1 \equiv 0 \pmod N $$

Si $r$ es par, se puede factorizar usando la fórmula de diferencia de cuadrados.

$$ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $$

Esto significa que $N$ tiene un factor común con $(a^{r/2} - 1)$ o con $(a^{r/2} + 1)$ (siempre que se cumpla la condición $a^{r/2} \not\equiv -1 \pmod N$). Por lo tanto, utilizando el algoritmo de Euclides, calculando

$$ p = \gcd(a^{r/2} - 1, N) $$ $$ q = \gcd(a^{r/2} + 1, N) $$

podemos encontrar los factores primos no triviales $p, q$ de $N$. Este cálculo (el cálculo del máximo común divisor y la generación de números aleatorios) se puede realizar de manera muy rápida en una computadora clásica. El problema se reduce a cómo encontrar rápidamente el período $r$. En una computadora clásica, encontrar este período $r$ en sí mismo requiere un tiempo exponencial. Aquí es donde entra en juego la computadora cuántica.

4. Parte del algoritmo cuántico: Mecanismo de búsqueda de período

La subrutina para encontrar el período $r$ utilizando una computadora cuántica consta de los siguientes cuatro pasos.

graph LR subgraph "Transición del estado cuántico" S1["|0⟩|0⟩ (Inicialización)"] --> S2["Compuerta H: Superposición Σ|x⟩|0⟩"] S2 --> S3["Oráculo U: Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT: Extracción del período por interferencia"] S4 --> S5["Medición: Obtención del valor aproximado y"] end

Paso 1: Inicialización de los registros cuánticos y superposición

Primero, preparamos dos registros cuánticos. El primer registro es para la entrada de estado, y el segundo registro es para almacenar el resultado del cálculo de la función. El estado inicial es todo $|0\rangle$.

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

Aplicamos la compuerta de Hadamard (Hadamard Gate) a todos los qubits del primer registro, creando un estado de superposición equiprobable de todas las entradas posibles $x$ (desde $0$ hasta $Q-1$, $Q=2^n$).

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

De esta manera, la computadora cuántica mantendrá los estados de todas las $Q$ entradas simultáneamente en una sola operación. Esta es la poderosa fuente del paralelismo cuántico.

Paso 2: Aplicación de la función oráculo (exponenciación modular)

A continuación, utilizamos el circuito de operación cuántica $U_f$ para calcular la función $f(x) = a^x \bmod N$ y almacenamos el resultado en el segundo registro.

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

En este punto, el primer y el segundo registro se encuentran en un estado de entrelazamiento cuántico (Entanglement). Si (hipotéticamente) observáramos el segundo registro y obtuviéramos un valor específico $k = a^{x_0} \bmod N$, el estado del primer registro colapsaría a una superposición de las $x$ que producen ese valor $k$. Dado que el período de la función es $r$, los estados restantes serán valores separados por $r$: $x_0, x_0+r, x_0+2r, \dots$

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

Sin embargo, no queremos conocer $x_0$, sino el período $r$ en sí. Es imposible observar $r$ directamente desde este estado. Por lo tanto, utilizamos la transformada de Fourier cuántica.

Paso 3: Interferencia de fase mediante la Transformada de Fourier Cuántica (QFT)

Aplicamos la Transformada de Fourier Cuántica (Quantum Fourier Transform, QFT) al primer registro. La QFT es la versión cuántica de la transformada de Fourier discreta clásica y transforma la amplitud del vector de estado. La acción de la QFT sobre el estado base $|x\rangle$ se define de la siguiente manera:

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

Aquí, $\omega = e^{2\pi i / Q}$.

Al aplicar la QFT, las amplitudes de estado interfieren. Omitiendo los detalles matemáticos, cuando se aplica la QFT a un estado con período $r$, las ondas causan una interferencia constructiva (Constructive Interference) solo cuando $y$ es un valor extremadamente cercano a un múltiplo entero de $Q/r$. Para los demás estados, las amplitudes de probabilidad se anulan debido a la interferencia destructiva (Destructive Interference) y se acercan a cero.

Paso 4: Medición y expansión en fracciones continuas

Finalmente, medimos el primer registro. El valor $y$ obtenido de la medición satisfará la siguiente condición con alta probabilidad:

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

($c$ es un entero desconocido tal que $0 \le c < r$)

Al aplicar el algoritmo clásico de expansión en fracciones continuas (Continued Fraction Expansion) al número racional obtenido $y/Q$, calculamos la fracción aproximada $c/r$ y extraemos el período $r$ del denominador.

5. Implementación de simulación utilizando Python y Qiskit

Dado que la teoría por sí sola puede ser difícil de visualizar, simulemos realmente el algoritmo de Shor utilizando Python y el marco de cálculo cuántico de IBM, Qiskit.

Aquí implementaremos el escenario más clásico y famoso: “factorizar $N=15$ utilizando $a=7$”.

Preparación del entorno de ejecución

Instala Qiskit de antemano.

1

pip install qiskit qiskit-aer numpy

Resumen del código de implementación en Python

El siguiente código es un ejemplo de implementación del algoritmo de Shor especializado para $N=15, a=7$. Construir un circuito de exponenciación modular de propósito general tiene un costo computacional demasiado alto para los simuladores actuales, por lo que las operaciones de las compuertas para el caso específico de $a=7$ están programadas en duro (hardcoded).

 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


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. Función para construir la Transformada de Fourier Cuántica Inversa (QFT†)
def qft_dagger(n):
 """Genera un circuito de transformada de Fourier cuántica inversa de n qubits"""
 qc = QuantumCircuit(n)
 # Compuertas SWAP para invertir el orden
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # Aplicación de compuertas de fase controladas y compuertas H
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. Función para construir la operación de exponenciación modular controlada 7^x mod 15
def c_amod15(a, power):
 """Genera una compuerta U controlada para un a específico y su potencia (exclusivo para N=15)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # Lógica de codificación dura (hardcoding) de 7^x mod 15 para el caso a=7
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. Construcción del circuito cuántico principal
def shor_circuit(a, n_count):
 # n_count: Número de bits del registro de control
 # El registro objetivo requiere 4 bits para representar de 0 a 15
 qc = QuantumCircuit(n_count + 4, n_count)

 # Inicialización del primer registro (registro de control) (generación de superposición)
 for q in range(n_count):
 qc.h(q)

 # Inicialización del segundo registro (registro objetivo) a |1> (0001)
 qc.x(3 + n_count)

 # Aplicación de la operación de exponenciación modular controlada (Oráculo)
 for q in range(n_count):
 # Aplicación de la operación elevada a la potencia 2^q
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # Aplicación de la transformada de Fourier cuántica inversa al primer registro
 qc.append(qft_dagger(n_count), range(n_count))

 # Medición del primer registro
 qc.measure(range(n_count), range(n_count))
 return qc

# --- Sección de ejecución ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # Uso de 8 qubits para el registro de control (Q=256)

 print(f"Configuración de búsqueda: N={N}, a={a}, qubits de control={n_count}")

 # Generación del circuito
 qc = shor_circuit(a, n_count)

 # Ejecución en el simulador
 sim = AerSimulator()
 # Se recomienda usar transpile en las versiones recientes de Qiskit
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\nResultados de medición (cadena de bits: número de observaciones):")
 for bitstring, count in counts.items():
 print(f" {bitstring}: {count} veces")

 # Posprocesamiento clásico: Identificación del período r mediante expansión de fracciones continuas
 print("\n--- Cálculo del período y factorización ---")
 phases = []
 for output in counts:
 # Convertir cadena de bits a número decimal
 decimal = int(output, 2)
 # Fase = valor medido / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # Obtener la fracción aproximada por expansión de fracciones continuas. El límite del denominador es N=15
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"Valor observado: {decimal:3d} | Fase: {phase:.4f} | Fracción continua: {frac} | Período estimado r = {r}")

 # Comprobar si el período r es par y produce resultados válidos
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => ¡Éxito! Los factores primos de {N} son {guess1} y {guess2}.")
 else:
 print(f" => Solo factores triviales. Intentando de nuevo.")
 else:
 print(f" => Fallo porque el período es impar.")

Explicación del código y análisis de los resultados de ejecución

Al ejecutar el código anterior, como resultado de la medición del registro de control, se obtienen picos específicos (valores observados) con alta probabilidad. En el caso de n_count=8 ($Q=256$), si se trata de una computadora cuántica ideal (o un simulador), los valores observados como 0, 64, 128 y 192 aparecerán con una probabilidad abrumadora.

Si dividimos estos valores por $Q=256$, las fases $y/Q$ serán $0.0$, $0.25$, $0.5$ y $0.75$, respectivamente. Al expandir estas fases en fracciones continuas, obtenemos:

$0.25 \to 1/4$ (Período estimado $r=4$)
$0.50 \to 1/2$ (Período estimado $r=2$)
$0.75 \to 3/4$ (Período estimado $r=4$)

Utilizando el período obtenido $r=4$, calculamos los factores primos. Dado que $a=7, r=4$, $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

Impresionantemente, hemos tenido éxito en la factorización de $15 = 3 \times 5$.

[!TIP] Si se obtiene $y=128$ (fase $0.5$) como valor de medición, el denominador será $2$, y obtendremos un divisor del verdadero período $r=4$ en lugar del período real. En tales casos, se puede llegar al verdadero período ejecutando el algoritmo varias veces o examinando los múltiplos del $r$ obtenido.

6. Desafíos para la implementación práctica y los límites de la era NISQ

Si bien fue fácil factorizar $N=15$ en un simulador, factorizar RSA-2048 (un número decimal de 617 dígitos) utilizado en el mundo real presenta numerosos obstáculos para las computadoras cuánticas actuales.

La época en la que vivimos actualmente se llama la era NISQ (Noisy Intermediate-Scale Quantum: Cuántica de Escala Intermedia Ruidosa). Los qubits son extremadamente vulnerables al ruido ambiental y sufren “decoherencia” durante los cálculos, lo que destruye su estado.

Para ejecutar con precisión circuitos profundos (con muchas compuertas) como el algoritmo de Shor, la corrección de errores cuánticos (Quantum Error Correction), que corrige el ruido, es indispensable. Para crear un solo “qubit lógico” sin ruido, es necesario codificar miles de “qubits físicos” utilizando un código de superficie (Surface Code) u otros métodos.

Se estima que para romper la criptografía RSA de 2048 bits se requieren miles de qubits lógicos perfectos, y lograr esto requeriría una computadora cuántica tolerante a fallos (fault-tolerant) equipada con millones a decenas de millones de qubits físicos. Dado que los procesadores cuánticos más avanzados de la actualidad tienen solo unos cientos a unos pocos miles de qubits físicos, la criptografía mundial no se romperá de manera inminente.

[!WARNING] Sin embargo, existe un modelo de amenaza llamado “Store Now, Decrypt Later (Almacenar ahora, descifrar después)”. Los atacantes podrían adoptar la estrategia de almacenar masivamente comunicaciones confidenciales actualmente encriptadas en forma de datos cifrados, con el objetivo de descifrarlo todo en el momento en que se complete una computadora cuántica poderosa dentro de 10 a 20 años.

7. Transición hacia la Criptografía Post-Cuántica (PQC)

En preparación para la llegada de ese “Día Q (Q-Day)” (el día en que las computadoras cuánticas rompan la criptografía), los criptógrafos de todo el mundo, liderados por el Instituto Nacional de Estándares y Tecnología de EE. UU. (NIST), están avanzando en el desarrollo de la Criptografía Post-Cuántica (Post-Quantum Cryptography, PQC).

La PQC se basa en nuevos problemas matemáticos (problemas basados en retículos, polinomios multivariantes, funciones hash, etc.) que se consideran matemáticamente difíciles de resolver de manera eficiente incluso utilizando el algoritmo de Shor (o el algoritmo de Grover). Algoritmos como “CRYSTALS-Kyber” y “CRYSTALS-Dilithium” ya han sido seleccionados como estándares y su implementación en protocolos de comunicación para navegadores web e iMessage de Apple está comenzando gradualmente.

Para los ingenieros que gestionan la infraestructura de TI, incorporar “agilidad criptográfica (crypto-agility: la capacidad del diseño para cambiar rápidamente los esquemas criptográficos)” en sus sistemas para hacer la transición desde la actual RSA y la criptografía de curva elíptica a PQC será una misión importante en el futuro.

8. Conclusión

En este artículo, hemos proporcionado una explicación exhaustiva de aproximadamente 10,000 caracteres, que abarca desde los fundamentos teóricos y matemáticos del algoritmo de Shor hasta el mecanismo de extracción de períodos mediante la transformada de Fourier cuántica y, finalmente, un código de simulación concreto utilizando Python y Qiskit.

El hecho de que las leyes físicas del mundo microscópico de la mecánica cuántica estén subvirtiendo fundamentalmente la teoría de la complejidad computacional y la teoría de la criptografía, que son la base de la ciencia de la información macroscópica, es uno de los cambios de paradigma más emocionantes en la historia de la ciencia. No podemos quitarle los ojos de encima a las continuas batallas ofensivas y defensivas entre la tecnología de la computación cuántica, que continúa desarrollándose en tiempo real, y las nuevas tecnologías criptográficas que la enfrentan.

Te invitamos a ejecutar el código de Python presentado aquí en tu propio entorno para experimentar la “magia computacional” producida por la superposición de estados cuánticos y la interferencia.

Referencias

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Qiskit Documentation: https://qiskit.org/documentation/