Introducción

Las matrices unitarias son la piedra angular de la mecánica cuántica y, por ende, de la computación cuántica. Cada operación lógica en un circuito cuántico se representa mediante una matriz que preserva la norma del vector de estado, garantizando la reversibilidad y la conservación de la probabilidad.

En este artículo exploraremos:

• Conceptos teóricos de matrices unitarias.
• Su relación directa con los gates cuánticos.
• Algoritmos para generar matrices unitarias arbitrarias.
• Implementaciones prácticas en Python (NumPy y Qiskit).
• Comparativas de rendimiento y buenas prácticas para escalar a varios qubits.

¿Qué es una Matriz Unitaria?

Una matriz \(U\) es unitaria si cumple:

U†·U = I

donde \(U^{\dagger}\) es la conjugada transpuesta y \(I\) la identidad. Esto implica que las columnas (y filas) forman un conjunto ortonormal en \(\mathbb{C}^n\).

Propiedades clave:

• Preservación de la norma: \(\|U\psi\| = \|\psi\|\).
• Reversibilidad: \(U^{-1}=U^{\dagger}\).
• Determinante de módulo 1: \(|\det(U)|=1\).

Matices Unitarias en Computación Cuántica

En un circuito cuántico, el estado del sistema se representa como un vector columna \(|\psi\rangle\) de dimensión \(2^n\) para \(n\) qubits. Cada puerta cuántica corresponde a una matriz unitaria \(U\) de dimensión \(2^n\times2^n\) que actúa sobre el estado:

|\psi'\rangle = U|\psi\rangle

Algunas puertas elementales (una qubit) y sus matrices:

H = 1/\sqrt{2} \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix}

X = \begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix}

Puertas de dos qubits, como CNOT, se expresan en bloques 4×4 que también son unitarias.

Algoritmo para Generar Matrices Unitarias Aleatorias

Una técnica robusta es usar la decomposición QR de una matriz compleja con entradas gaussianas. El proceso garantiza una distribución uniforme en el grupo unitario \(U(N)\) (medida de Haar).

Pasos del algoritmo

1. Crear una matriz \(A\) de dimensión \(N\times N\) con números complejos \(a_{ij}=x_{ij}+iy_{ij}\), donde \(x_{ij},y_{ij}\sim\mathcal{N}(0,1)\).
2. Aplicar la factorización QR: \(A = QR\).
3. Corregir la fase de \(R\) para que los elementos diagonales tengan módulo 1: \(\Lambda = \text{diag}(R_{ii}/|R_{ii}|)\).
4. Obtener la matriz unitaria: \(U = Q\Lambda\).

Este método es escalable y se adapta a cualquier \(N=2^n\).

Implementación en Python

Usaremos numpy para operaciones lineales y qiskit para validar que la matriz resultante sea aceptada como puerta cuántica.

1️⃣ Generar una puerta unitaria 2‑qubits con QR

import numpy as np
from qiskit import QuantumCircuit
from qiskit.extensions import UnitaryGate
def random_unitary(dim):
    # paso 1: matriz gaussiana compleja
    A = (np.random.randn(dim, dim) + 1j*np.random.randn(dim, dim)) / np.sqrt(2)
    # paso 2: QR
    Q, R = np.linalg.qr(A)
    # paso 3: ajustar fase
    diag = np.diag(R)
    lam = diag / np.abs(diag)
    U = Q @ np.diag(lam)
    return U
U2 = random_unitary(4)   # 2 qubits → 2^2 = 4
print("Matriz unitaria aleatoria (2 qubits):\n", U2)
# Validación en Qiskit
qc = QuantumCircuit(2)
qc.append(UnitaryGate(U2), [0, 1])
print(qc.draw())

La salida muestra una matriz cuasi‑aleatoria que cumple \(U^{\dagger}U=I\) dentro de la tolerancia numérica.

2️⃣ Puertas básicas con Qiskit (Hadamard, CNOT)

from qiskit import Aer, execute
from qiskit.visualization import plot_state_city
qc = QuantumCircuit(2)
qc.h(0)          # Hadamard en qubit 0
qc.cx(0, 1)      # CNOT controlado por 0
backend = Aer.get_backend('statevector_simulator')
result = execute(qc, backend).result()
state = result.get_statevector()
plot_state_city(state)

Este circuito prepara el estado de Bell \((|00\rangle+|11\rangle)/\sqrt{2}\).

Comparativa de Frameworks Cuánticos

Ambos frameworks permiten crear puertas a partir de matrices arbitrarias; la elección depende del hardware objetivo y la preferencia de la comunidad.

Rendimiento y Escalabilidad

Al trabajar con \(n\) qubits, la dimensión de la matriz crece exponencialmente (\(2^n\times2^n\)). Algunas recomendaciones:

• Evitar almacenar matrices completas cuando sea posible; utilice descomposiciones (por ejemplo, Kraus, tensor networks).
• Para simulaciones, prefiera state‑vector o density‑matrix basadas en numpy de 64‑bits para mayor precisión.
• En hardware real, las puertas se describen mediante parámetros calibrados, no matrices explícitas.

Benchmarks típicos (CPU Intel i7‑12700K, Python 3.11):

dim   | tiempo QR (ms) | memoria (MiB)
----------------------------------------
2^3   | 0.3            | 0.5
2^5   | 2.1            | 4.2
2^7   | 18.7           | 35.0
2^9   | 170            | 280

Más allá de 9 qubits, la generación de matrices completas se vuelve impráctica y se recurre a técnicas de compresión.

Mejores Prácticas y Depuración

• Verificación de unitariedad: np.allclose(U.conj().T @ U, np.eye(N), atol=1e-12).
• Control de fase global: En muchos algoritmos la fase global es irrelevante; sin embargo, para interferencia cuántica sí importa.
• Uso de simuladores cuánticos antes de ejecutar en hardware para detectar errores de dimensión.
• Logging estructurado de matrices y parámetros para reproducibilidad.

Seguridad y Criptografía Cuántica

Las matrices unitarias también aparecen en protocolos de Quantum Key Distribution (QKD). Asegurarse de que las puertas implementadas respeten la unitariedad es crucial para mantener la seguridad teórica del protocolo (por ejemplo, BB84 usa rotaciones que son unitarias).

Conclusión

Dominar la generación y manipulación de matrices unitarias es esencial para cualquier desarrollador que quiera adentrarse en la computación cuántica. Con Python, NumPy y Qiskit, podemos crear, validar y ejecutar puertas cuánticas tanto en simuladores como en hardware real, mientras seguimos las mejores prácticas de rendimiento y seguridad.