Álgebra lineal para computación cuántica: lo esencial que necesitas saber

📅 Última actualización: diez de abril de dos mil veintiséis

📑 Índice de contenidos

Por qué el álgebra lineal es el idioma de la computación cuántica

La computación cuántica no requiere entender la ecuación de Schrödinger ni la electrodinámica cuántica. Lo que requiere, de forma ineludible, es álgebra lineal. Cada concepto fundamental de la computación cuántica tiene una traducción directa a operaciones con vectores y matrices: un qubit es un vector unitario en un espacio de dos dimensiones, una puerta cuántica es una matriz unitaria que transforma ese vector, una medición es una proyección sobre un subespacio propio, y el entrelazamiento es la imposibilidad de factorizar un vector como producto tensorial.

Si dominas el álgebra lineal que cubre este artículo, podrás entender cualquier circuito cuántico, verificar manualmente los resultados de Qiskit o Cirq, y leer papers de investigación cuántica con soltura. No es exageración: el álgebra lineal es literalmente todo lo que necesitas para los fundamentos.

Vectores como estados cuánticos: tu primer qubit matemático

Un qubit es un vector unitario en un espacio vectorial complejo de dos dimensiones. Los dos vectores base son |0⟩ = (1, 0)ᵀ y |1⟩ = (0, 1)ᵀ, que corresponden a los dos estados clásicos de un bit. Un estado cuántico general es una combinación lineal |ψ⟩ = α|0⟩ + β|1⟩ donde α y β son números complejos tales que |α|² + |β|² = 1.

import numpy as np

# Estados base
ket_0 = np.array([1, 0], dtype=complex)
ket_1 = np.array([0, 1], dtype=complex)

# Superposición: |+⟩ = (|0⟩ + |1⟩) / √2
ket_plus = (ket_0 + ket_1) / np.sqrt(2)
print(f"|+⟩ = {ket_plus}")
# [0.707+0j, 0.707+0j]

# Probabilidades
prob_0 = np.abs(ket_plus[0])**2  # 0.5
prob_1 = np.abs(ket_plus[1])**2  # 0.5

La condición de normalización |α|² + |β|² = 1 garantiza que las probabilidades de medir cada resultado suman uno. Esta es la conexión directa entre el álgebra lineal y la superposición cuántica: la superposición no es más que una combinación lineal con coeficientes complejos de norma total unitaria.

Notación de Dirac: bras, kets y productos internos

La notación de Dirac es el lenguaje estándar de la mecánica cuántica y la computación cuántica. Un ket |ψ⟩ representa un vector columna (estado cuántico). Un bra ⟨ψ| es el conjugado transpuesto del ket correspondiente (un vector fila). El braket ⟨φ|ψ⟩ es el producto interno entre dos estados: un número complejo que mide la «similitud» entre los estados.

# Notación de Dirac en NumPy
# |0⟩ y |1⟩ son ortogonales
braket_00 = np.vdot(ket_0, ket_0)  # ⟨0|0⟩ = 1
braket_01 = np.vdot(ket_0, ket_1)  # ⟨0|1⟩ = 0

# Probabilidad de medir |0⟩ en estado |+⟩
prob = np.abs(np.vdot(ket_0, ket_plus))**2  # |⟨0|+⟩|² = 0.5

La regla de Born, que conecta el álgebra lineal con la física cuántica, establece que la probabilidad de medir el estado |φ⟩ cuando el sistema está en |ψ⟩ es exactamente |⟨φ|ψ⟩|². Todo el aparato probabilístico de la mecánica cuántica emerge del producto interno del álgebra lineal.

Matrices unitarias: las puertas cuánticas son transformaciones

Las puertas cuánticas son matrices unitarias: matrices cuadradas U tales que U†U = I (donde U† es la conjugada transpuesta de U). La unitariedad garantiza que la evolución cuántica preserva la norma del estado, es decir, que las probabilidades siguen sumando uno después de aplicar la puerta.

# Puertas cuánticas como matrices
H = np.array([[1, 1], [1, -1]]) / np.sqrt(2)  # Hadamard
X = np.array([[0, 1], [1, 0]])                  # Pauli X (NOT)
Z = np.array([[1, 0], [0, -1]])                  # Pauli Z

# Verificar unitariedad
print(np.allclose(H @ H.conj().T, np.eye(2)))  # True

# Aplicar Hadamard a |0⟩
resultado = H @ ket_0  # = |+⟩
print(f"H|0⟩ = {resultado}")  # [0.707, 0.707]

La CNOT (Controlled-NOT), la puerta de dos qubits más importante, es una matriz cuatro por cuatro que actúa sobre el espacio de dos qubits:

CNOT = np.array([
    [1, 0, 0, 0],
    [0, 1, 0, 0],
    [0, 0, 0, 1],
    [0, 0, 1, 0]
])
# CNOT flips the target qubit if control is |1⟩

Valores propios y medición cuántica

La medición cuántica está íntimamente conectada con la descomposición espectral de operadores hermíticos. Cuando mides un qubit en la base computacional, estás proyectando el estado sobre los vectores propios de la matriz Z. Los valores propios (+1 y -1 para Z) corresponden a los resultados de la medición (|0⟩ y |1⟩ respectivamente), y las probabilidades son los cuadrados de las amplitudes de la descomposición.

# Valores propios de Z
eigenvalues, eigenvectors = np.linalg.eigh(Z)
print(f"Valores propios: {eigenvalues}")  # [-1, 1]
# Correspondencia: eigenvalue +1 → |0⟩, -1 → |1⟩

El producto tensorial: de un qubit a muchos

El producto tensorial (⊗) es la operación que construye el espacio de estados de sistemas multi-qubit. Si un qubit vive en un espacio de dimensión dos, dos qubits viven en un espacio de dimensión cuatro (2⊗2), tres qubits en dimensión ocho (2⊗2⊗2), y n qubits en dimensión 2ⁿ. Este crecimiento exponencial es la fuente del poder de la computación cuántica.

# Producto tensorial con NumPy
# |00⟩ = |0⟩ ⊗ |0⟩
ket_00 = np.kron(ket_0, ket_0)  # [1, 0, 0, 0]
ket_01 = np.kron(ket_0, ket_1)  # [0, 1, 0, 0]

# Estado Bell: no factorizable como producto tensorial
bell = (np.kron(ket_0, ket_0) + np.kron(ket_1, ket_1)) / np.sqrt(2)
# [0.707, 0, 0, 0.707] = entrelazado

El entrelazamiento cuántico tiene una definición algebraica precisa: un estado de dos o más qubits está entrelazado si y solo si no puede escribirse como producto tensorial de estados individuales. El estado Bell del ejemplo es entrelazado porque no existen vectores |a⟩ y |b⟩ tales que |a⟩⊗|b⟩ produzca ese vector.

Espacios de Hilbert: dónde viven los estados cuánticos

Un espacio de Hilbert es un espacio vectorial complejo con producto interno que es completo (toda sucesión de Cauchy converge). Para computación cuántica con n qubits, el espacio de Hilbert es ℂ^(2ⁿ): el espacio de todos los vectores complejos de dimensión 2ⁿ. Este espacio crece exponencialmente: diez qubits necesitan vectores de mil veinticuatro componentes, treinta qubits necesitan más de mil millones.

Esta explosión exponencial es exactamente la razón por la que los simuladores clásicos no pueden simular más de cuarenta-cincuenta qubits: necesitarían almacenar y manipular vectores con más de un billón de componentes complejos. Y es exactamente la razón por la que los ordenadores cuánticos pueden, en principio, resolver problemas intratables clásicamente: operan nativamente en espacios exponencialmente grandes.

Matrices de densidad: más allá de estados puros

Cuando un sistema cuántico interactúa con su entorno (lo que ocurre inevitablemente en procesadores reales debido a la decoherencia), su estado ya no puede describirse como un vector puro sino como una mezcla estadística representada por una matriz de densidad ρ: una matriz hermítica, semidefinida positiva y con traza unitaria.

# Estado puro |+⟩ como matriz de densidad
rho_pure = np.outer(ket_plus, ket_plus.conj())
# [[0.5, 0.5], [0.5, 0.5]]

# Estado mixto: 50% |0⟩ y 50% |1⟩ (mezcla clásica)
rho_mixed = 0.5 * np.outer(ket_0, ket_0.conj()) + 0.5 * np.outer(ket_1, ket_1.conj())
# [[0.5, 0], [0, 0.5]]

# Diferencia: los elementos fuera de la diagonal (coherencias)
# rho_pure tiene coherencias, rho_mixed no

Cheat sheet: las fórmulas esenciales en una tabla

Ejercicios prácticos con Python y NumPy

La mejor forma de interiorizar estos conceptos es implementarlos. Te propongo tres ejercicios progresivos. El primero: implementa las matrices de las puertas H, X, Y, Z, S, T y CNOT, y verifica que todas son unitarias. El segundo: crea una función que tome un estado de dos qubits y determine si está entrelazado o no (pista: calcula la descomposición de Schmidt o intenta factorizarlo como producto tensorial). El tercero: simula un circuito de teletransportación cuántica completo usando solo NumPy, sin Qiskit ni Cirq.

Estos ejercicios te darán la base matemática sólida para abordar los tutoriales de Qiskit y Cirq con confianza, sabiendo exactamente qué operaciones matemáticas se ejecutan detrás de cada línea de código.

Preguntas frecuentes

Espacios vectoriales y notación de Dirac para programadores

Para programadores que se aproximan a la computación cuántica, el mayor obstáculo conceptual es la notación de Dirac (bra-ket), que es simplemente una forma elegante de escribir vectores y operaciones con vectores. Un ket |0⟩ es un vector columna que representa el estado cero del qubit. Un bra ⟨0| es su vector fila conjugado transpuesto. El producto interno ⟨0|1⟩ mide la similitud entre dos estados (cero si son ortogonales, uno si son idénticos). El producto externo |0⟩⟨1| crea una matriz que transforma un estado en otro.

La ventaja de esta notación para la computación cuántica es que hace explícitas las operaciones que un circuito cuántico realiza. Cuando aplicas una puerta Hadamard a |0⟩, el resultado es (|0⟩ + |1⟩) dividido por raíz de dos, una superposición que se lee directamente como combinación lineal de estados base. Para programadores acostumbrados a pensar en bits que son cero o uno, la superposición es el salto conceptual fundamental: un qubit no es cero ni uno sino una combinación de ambos con amplitudes complejas que determinan la probabilidad de obtener cada resultado al medir.

Matrices y operadores: las puertas cuánticas como transformaciones lineales

Las puertas cuánticas son matrices unitarias que transforman estados cuánticos. La puerta X (NOT cuántica) es la matriz [[0,1],[1,0]] que intercambia |0⟩ y |1⟩. La puerta Hadamard es la matriz [[1,1],[1,-1]] dividida por raíz de dos que crea superposiciones. La puerta CNOT es una matriz cuatro por cuatro que invierte el qubit objetivo solo si el qubit de control está en estado uno, creando entrelazamiento entre ambos qubits.

La propiedad esencial de todas las puertas cuánticas es que son unitarias: su inversa es su conjugada transpuesta. Esto garantiza que la información cuántica se conserva (no se pierde ni se crea) durante la computación, una restricción fundamental de la mecánica cuántica que no tiene equivalente en la computación clásica. En la práctica, esto significa que todo circuito cuántico es reversible: dados los qubits de salida, siempre es posible reconstruir los de entrada aplicando las puertas en orden inverso.

Producto tensorial: cómo crecen los sistemas cuánticos

El producto tensorial es la operación que conecta qubits individuales en sistemas multi-qubit. Si un qubit está en estado |0⟩ y otro en estado |1⟩, el sistema de dos qubits está en estado |0⟩ tensor |1⟩, que se escribe |01⟩ y es un vector de cuatro componentes. Con tres qubits el espacio tiene ocho dimensiones, con diez qubits tiene mil veinticuatro, y con N qubits tiene dos elevado a N dimensiones.

Este crecimiento exponencial del espacio de estados es la fuente del poder computacional cuántico: un sistema de cincuenta qubits tiene un espacio de estados de más de mil billones de dimensiones, más que la memoria de cualquier supercomputador existente. Pero también es la razón por la que simular un ordenador cuántico en un ordenador clásico se vuelve imposible más allá de unas pocas decenas de qubits. La simulación clásica requiere almacenar y manipular vectores de dos elevado a N componentes complejos, un problema que crece exponencialmente con el número de qubits.

Autovalores y autoestados: la base de los algoritmos cuánticos

Los autovalores y autovectores son fundamentales para entender los algoritmos cuánticos más importantes. El algoritmo de Shor para factorizar números se basa en encontrar el período de una función modular, que es esencialmente un problema de autovalores de un operador de desplazamiento. El algoritmo de Grover para búsqueda en bases de datos no ordenadas utiliza reflexiones sobre autoespacios para amplificar la amplitud del estado objetivo. VQE busca el autovalor mínimo de un Hamiltoniano molecular, que corresponde a la energía del estado fundamental de la molécula.

Para programadores, la intuición clave es que los autovectores de un operador cuántico son los estados que no cambian de dirección cuando se les aplica el operador (solo cambian de escala, que es el autovalor). La medición cuántica colapsa el estado del qubit a un autovector del observable medido, y el resultado obtenido es el autovalor correspondiente. Toda la computación cuántica se reduce, en última instancia, a preparar estados que se alineen con los autovectores de interés y medir para obtener los autovalores que codifican la solución del problema.

Números complejos en la computación cuántica

Los amplitudes de los estados cuánticos son números complejos, no reales. Un estado general de un qubit es alfa|0⟩ más beta|1⟩ donde alfa y beta son números complejos cuyo módulo al cuadrado suma uno. La fase compleja (la parte imaginaria) no afecta a las probabilidades de medición individuales pero sí a las interferencias entre estados, que son el mecanismo fundamental que permite a los algoritmos cuánticos amplificar las soluciones correctas y cancelar las incorrectas.

Para programadores que nunca han trabajado con números complejos, el punto clave es que las fases importan: dos estados con las mismas probabilidades de medición pero diferentes fases se comportan de manera radicalmente diferente cuando se les aplican puertas adicionales. La puerta Z, por ejemplo, cambia la fase de |1⟩ sin modificar las probabilidades, pero este cambio invisible afecta a todas las operaciones subsiguientes. Dominar la intuición sobre fases es lo que separa a un programador cuántico novato de uno experto, y es el concepto matemático que más beneficio tiene practicar hasta que se interiorice.

Estos fundamentos de álgebra lineal son suficientes para comprender y programar la mayoría de algoritmos cuánticos. Los recursos complementarios de Qiskit, Cirq y simuladores gratuitos permiten experimentar con estos conceptos de forma práctica, traduciendo la teoría abstracta en código ejecutable que consolida la comprensión mucho más rápido que el estudio puramente teórico.

Descomposición espectral y su aplicación práctica

La descomposición espectral de una matriz es el proceso de expresarla como suma ponderada de sus proyectores sobre autoestados. En computación cuántica, esto es directamente aplicable a la medición: cuando medimos un observable cuántico (representado por una matriz hermítica), el resultado es uno de sus autovalores, y el estado del sistema colapsa al autoestado correspondiente. La probabilidad de obtener cada autovalor está dada por el módulo al cuadrado de la proyección del estado actual sobre el autoestado.

Para algoritmos como VQE, la descomposición del Hamiltoniano molecular en suma de operadores de Pauli (I, X, Y, Z y sus productos tensoriales) es una aplicación directa de la descomposición espectral que permite medir la energía molecular mediante múltiples mediciones simples de qubits individuales. Cada término de Pauli se mide independientemente y los resultados se combinan clásicamente, una técnica que transforma un problema de medición complejo en una serie de mediciones elementales que cualquier procesador cuántico actual puede ejecutar.

Ejercicios prácticos: del papel al código

Para consolidar estos conceptos, recomendamos una secuencia de ejercicios progresivos. Primero, implementar la multiplicación de matrices dos por dos en Python puro (sin NumPy) para interiorizar la mecánica del producto matricial. Segundo, verificar que las puertas cuánticas X, Y, Z y H son unitarias comprobando que U multiplicado por U-daga produce la identidad. Tercero, calcular manualmente el estado resultante de aplicar H al qubit |0⟩ y verificar con Qiskit que el simulador produce el mismo resultado.

Cuarto, construir el estado de Bell aplicando H seguido de CNOT a |00⟩ y verificar que los dos qubits están perfectamente correlacionados. Quinto, implementar el producto tensorial de dos vectores de estado y comprobar que el resultado coincide con lo que el simulador produce para el sistema de dos qubits. Estos cinco ejercicios, que se completan en una tarde de trabajo, proporcionan la intuición práctica necesaria para abordar cualquier tutorial de programación cuántica con confianza en los fundamentos matemáticos subyacentes.

El álgebra lineal es el lenguaje nativo de la computación cuántica, y dominarlo transforma la experiencia de aprendizaje de memorizar recetas a entender profundamente por qué los algoritmos funcionan. Con estos fundamentos sólidos, los tutoriales de frameworks como Qiskit, Cirq y PennyLane dejan de ser cajas negras y se convierten en implementaciones comprensibles de conceptos matemáticos que ya dominas. La inversión de tiempo en álgebra lineal se amortiza multiplicada en cada algoritmo cuántico que aprendas después.