Tutorial Cirq en Español 2026: Procesador

📅 Última actualización: uno de marzo de dos mil veintiséis

📑 Índice de contenidos

Qué es Cirq y cuándo elegirlo sobre Qiskit

Cirq es un framework de computación cuántica de código abierto desarrollado por Google Quantum AI. Mientras que Qiskit de IBM se diseñó como una herramienta generalista accesible para principiantes, Cirq nació con un objetivo más específico: proporcionar el control más fino posible sobre el hardware cuántico para optimizar circuitos en la era NISQ, donde cada puerta cuántica adicional introduce errores que degradan el resultado.

La filosofía de diseño de Cirq refleja la realidad de los procesadores cuánticos actuales. En un ordenador cuántico real, no todos los qubits están conectados entre sí, las puertas cuánticas tienen tasas de error diferentes según qué par de qubits involucren, y el tiempo de coherencia limita cuántas operaciones puedes ejecutar antes de que la decoherencia cuántica destruya la información. Cirq te permite trabajar con estas restricciones de forma explícita, algo que otros frameworks abstraen o esconden.

Deberías elegir Cirq si tu objetivo es optimizar circuitos para hardware real, investigar algoritmos NISQ, trabajar con modelos de ruido detallados o eventualmente ejecutar código en los procesadores de Google. Si estás empezando desde cero en computación cuántica, Qiskit sigue siendo más accesible, pero si ya tienes fundamentos y quieres profundizar en el rendimiento real de los circuitos, Cirq es la herramienta adecuada.

Instalación y primer circuito

Cirq se instala con pip como cualquier paquete de Python. Recomiendo un entorno virtual dedicado:

pip install cirq

# Verificar instalación
import cirq
print(cirq.__version__)

# Primer circuito: poner un qubit en superposición
qubit = cirq.LineQubit(0)
circuit = cirq.Circuit([
    cirq.H(qubit),           # Hadamard: crear superposición
    cirq.measure(qubit, key='resultado')  # Medir
])
print(circuit)
# Output:
# 0: ───H───M('resultado')───

La representación textual de los circuitos en Cirq es una de sus características más apreciadas: muestra visualmente la secuencia de puertas aplicadas a cada qubit, facilitando la comprensión y depuración de circuitos complejos.

Qubits en Cirq: LineQubit, GridQubit y NamedQubit

A diferencia de Qiskit donde los qubits son simplemente índices numéricos, Cirq ofrece tres tipos de qubits que reflejan diferentes topologías de hardware. LineQubit modela qubits dispuestos en línea (como un registro cuántico lineal). GridQubit modela qubits en una rejilla bidimensional, exactamente como están dispuestos los qubits en los procesadores Sycamore y Willow de Google. NamedQubit permite crear qubits con nombres arbitrarios para prototipado abstracto.

# Tres formas de crear qubits
linea = cirq.LineQubit.range(5)       # 5 qubits en línea: 0,1,2,3,4
rejilla = cirq.GridQubit.rect(2, 3)   # 6 qubits en rejilla 2x3
nombre = cirq.NamedQubit("mi_qubit")  # Qubit con nombre

print(f"Línea: {linea}")
print(f"Rejilla: {rejilla}")
# Rejilla: [q(0,0), q(0,1), q(0,2), q(1,0), q(1,1), q(1,2)]

Esta distinción de tipos de qubit es fundamental cuando programas para hardware real. En el procesador Sycamore de Google, los qubits están en una rejilla donde solo qubits adyacentes pueden interactuar directamente. Si necesitas aplicar una puerta CNOT entre qubits no adyacentes, Cirq necesita insertar puertas SWAP intermedias, y modelar esto correctamente requiere saber la posición física de cada qubit.

Puertas cuánticas y operaciones en Cirq

Cirq implementa un conjunto completo de puertas cuánticas. Las más utilizadas incluyen Hadamard, rotaciones parametrizadas, CNOT y la puerta CZ (la puerta nativa de los procesadores de Google):

Un detalle importante: la puerta CZ (Controlled-Z) es la puerta nativa de dos qubits en los procesadores de Google. Esto significa que cuando compilas tu circuito para ejecutarse en hardware de Google, todas las puertas de dos qubits se descomponen en combinaciones de CZ y puertas de un qubit. Programar directamente con CZ en lugar de CNOT puede reducir la profundidad del circuito y mejorar la calidad de los resultados.

Circuitos con momentos: la estructura temporal de Cirq

Una característica única de Cirq es su concepto de Moments (momentos): grupos de operaciones que se ejecutan simultáneamente en el mismo paso temporal. Mientras que en Qiskit las puertas se aplican secuencialmente y el framework decide la paralelización, en Cirq tú controlas explícitamente qué operaciones se ejecutan en paralelo:

q0, q1, q2 = cirq.LineQubit.range(3)

# Momento 1: tres Hadamard en paralelo
# Momento 2: dos CNOT (q0→q1 y q1→q2 no se pueden paralelizar)
circuit = cirq.Circuit([
    cirq.Moment([cirq.H(q0), cirq.H(q1), cirq.H(q2)]),
    cirq.Moment([cirq.CNOT(q0, q1)]),
    cirq.Moment([cirq.CNOT(q1, q2)]),
    cirq.measure(q0, q1, q2, key='m')
])
print(f"Profundidad: {len(circuit)} momentos")

Controlar la estructura temporal es crucial en procesadores NISQ porque la profundidad del circuito (número de momentos) determina directamente cuánto tiempo necesita la ejecución, y por tanto cuánta decoherencia acumula. Un circuito más paralelo (menor profundidad) produce resultados más fiables que un circuito secuencial equivalente.

Entrelazamiento cuántico: crear un estado Bell

Vamos a crear un estado Bell, el ejemplo fundamental de entrelazamiento cuántico. Dos qubits entrelazados muestran correlaciones perfectas que no pueden explicarse por la física clásica:

q0, q1 = cirq.LineQubit.range(2)

# Estado Bell: |00⟩ + |11⟩ (normalizado)
bell_circuit = cirq.Circuit([
    cirq.H(q0),            # Superposición en q0
    cirq.CNOT(q0, q1),     # Entrelazar q0 con q1
    cirq.measure(q0, q1, key='bell')
])

# Simular 1000 veces
sim = cirq.Simulator()
result = sim.run(bell_circuit, repetitions=1000)
counts = result.histogram(key='bell')
print(f"Resultados: {counts}")
# Resultado típico: {0: ~500, 3: ~500}
# 0 = |00⟩, 3 = |11⟩ → solo resultados correlacionados

Observa que solo obtenemos los resultados cero cero y uno uno, nunca cero uno ni uno cero. Esta correlación perfecta entre qubits separados es la esencia del entrelazamiento cuántico y la base de la mayoría de algoritmos cuánticos, desde la teletransportación hasta la distribución de clave cuántica.

Simulación: ejecutar circuitos sin hardware real

Cirq incluye varios simuladores con diferentes capacidades. El simulador estándar calcula el estado cuántico exacto, ideal para aprender y depurar. Para circuitos más grandes, el simulador de vectores de estado es más eficiente:

# Simulador estándar con estado completo
sim = cirq.Simulator()
result = sim.simulate(bell_circuit)
print(f"Estado final: {result.final_state_vector}")
# [0.707+0j, 0+0j, 0+0j, 0.707+0j]

# Simulador de muestreo (más rápido para muchas repeticiones)
result = sim.run(bell_circuit, repetitions=10000)
print(f"Histograma: {result.histogram(key='bell')}")

La diferencia entre simulate (que devuelve el vector de estado completo) y run (que devuelve muestras como un procesador real) es crucial para entender la computación cuántica. En un ordenador cuántico real solo puedes obtener muestras: cada ejecución colapsa el estado cuántico en una medición clásica, y necesitas muchas repeticiones para reconstruir la distribución de probabilidades.

Simulación con ruido: modelar procesadores NISQ reales

Una de las fortalezas principales de Cirq es su soporte nativo para modelos de ruido detallados. Los procesadores cuánticos actuales están afectados por múltiples fuentes de error, y simular estos errores es esencial para predecir cómo se comportará tu circuito en hardware real:

# Modelo de ruido simple: error de despolarización
noise_model = cirq.ConstantQubitNoiseModel(
    qubit_noise_gate=cirq.DepolarizingChannel(p=0.01)
)

# Simulador con ruido
noisy_sim = cirq.DensityMatrixSimulator(noise=noise_model)
noisy_result = noisy_sim.run(bell_circuit, repetitions=1000)
noisy_counts = noisy_result.histogram(key='bell')
print(f"Con ruido: {noisy_counts}")
# Ahora aparecen resultados 01 y 10 (errores)

Comparar los resultados ideales (sin ruido) con los ruidosos te da una medida directa de cómo el hardware imperfecto afecta a tu algoritmo. Esta capacidad es fundamental para la investigación en corrección de errores cuánticos y para el desarrollo de algoritmos tolerantes al ruido.

Algoritmo de Grover en Cirq: búsqueda cuántica paso a paso

Implementemos el algoritmo de Grover, que busca un elemento marcado en una base de datos no estructurada con aceleración cuadrática respecto a la búsqueda clásica. Para dos qubits (cuatro elementos), el algoritmo encuentra el elemento marcado en una sola iteración:

q0, q1 = cirq.LineQubit.range(2)

# Buscar el estado |11⟩
grover = cirq.Circuit([
    # Superposición inicial
    cirq.H(q0), cirq.H(q1),
    # Oráculo: marca |11⟩ con fase negativa
    cirq.CZ(q0, q1),
    # Difusión de Grover
    cirq.H(q0), cirq.H(q1),
    cirq.X(q0), cirq.X(q1),
    cirq.CZ(q0, q1),
    cirq.X(q0), cirq.X(q1),
    cirq.H(q0), cirq.H(q1),
    # Medir
    cirq.measure(q0, q1, key='grover')
])

sim = cirq.Simulator()
result = sim.run(grover, repetitions=1000)
print(f"Grover: {result.histogram(key='grover')}")
# {3: 1000} → encuentra |11⟩ el 100% de las veces

El algoritmo de Grover demuestra una ventaja cuántica teórica clara: buscar en una lista de N elementos requiere O(√N) consultas cuánticas frente a O(N) consultas clásicas. Aunque la ventaja es cuadrática (no exponencial como en el algoritmo de Shor), para bases de datos enormes la diferencia es enorme.

Optimización de circuitos: reducir profundidad para hardware real

Cirq incluye herramientas potentes para optimizar circuitos antes de ejecutarlos en hardware. Estas optimizaciones reducen la profundidad del circuito y el número de puertas, mejorando directamente la calidad de los resultados en procesadores NISQ:

# Optimizar un circuito
optimized = cirq.optimize_for_target_gateset(
    grover,
    gateset=cirq.SqrtIswapTargetGateset()
)
print(f"Original: {len(grover)} momentos")
print(f"Optimizado: {len(optimized)} momentos")

La optimización automática de circuitos es una de las áreas donde Cirq brilla especialmente. El framework conoce las restricciones específicas de los procesadores de Google (qué puertas son nativas, qué qubits están conectados, qué fidelidades tienen) y puede compilar tu circuito de alto nivel a una secuencia de operaciones nativas que minimiza la profundidad y los errores.

Cirq versus Qiskit versus PennyLane: comparativa final

Mi recomendación como desarrolladora cuántica: aprende los tres. Empieza con Qiskit para los fundamentos, pasa a Cirq cuando quieras optimizar para hardware real, y añade PennyLane cuando explores quantum machine learning. Los tres son complementarios y dominarlos te convierte en un profesional cuántico versátil, algo que el mercado laboral valora enormemente. Para más herramientas, consulta nuestra guía de simuladores cuánticos gratuitos.

Preguntas frecuentes

Circuitos parametrizados en Cirq para algoritmos variacionales

Una de las fortalezas de Cirq frente a otros frameworks es su manejo nativo de circuitos parametrizados, esenciales para algoritmos variacionales como VQE y QAOA. En Cirq, los parámetros se definen como sympy.Symbol y se resuelven en tiempo de ejecución, permitiendo crear plantillas de circuito reutilizables que se evalúan con diferentes valores sin reconstruir el circuito.

import cirq
import sympy

# Parametros simbolicos
theta = sympy.Symbol('theta')
phi = sympy.Symbol('phi')

q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit([
    cirq.H(q0),
    cirq.ry(theta)(q1),
    cirq.CNOT(q0, q1),
    cirq.rz(phi)(q0),
    cirq.measure(q0, q1, key='result')
])

# Resolver con valores concretos
resolver = cirq.ParamResolver({'theta': 0.5, 'phi': 1.2})
result = cirq.Simulator().simulate(circuit, resolver)
print(result.final_state_vector)

Esta capacidad de parametrización es la base de todo el machine learning cuántico con Cirq. Los circuitos parametrizados actúan como modelos entrenables donde los parámetros (theta, phi) se optimizan con gradiente descendente para minimizar una función de coste, exactamente como los pesos de una red neuronal clásica.

TensorFlow Quantum: la integración profunda de Cirq con ML

TensorFlow Quantum (TFQ) es la biblioteca que conecta Cirq con el ecosistema de TensorFlow, permitiendo crear modelos híbridos cuántico-clásicos entrenables end-to-end con las mismas herramientas que se usan para deep learning clásico. Con TFQ puedes definir una capa cuántica (un circuito Cirq parametrizado), combinarla con capas Dense, Conv2D o cualquier otra de Keras, y entrenar el modelo completo con backpropagation.

La ventaja de TFQ sobre implementar el bucle variacional manualmente es la eficiencia: TFQ implementa el parameter-shift rule para calcular gradientes cuánticos y los integra transparentemente con el autograd de TensorFlow, eliminando la necesidad de escribir código de optimización personalizado. Para data scientists que ya conocen TensorFlow, TFQ es la entrada más natural al quantum machine learning.

Ejecutar Cirq en procesadores Google: de Sycamore a los sistemas actuales

La motivación original de Google para desarrollar Cirq fue proporcionar acceso nativo a sus procesadores cuánticos superconductores. La ejecución en hardware real a través de Google Cloud requiere una cuenta de Google Cloud con la API de Quantum Engine habilitada. Los circuitos se envían como jobs asíncronos y los resultados se recogen cuando el procesador los completa.

La experiencia de ejecutar en hardware real difiere significativamente de la simulación. Los resultados son inherentemente probabilísticos y ruidosos: un circuito que en simulador produce el estado cero-cero con probabilidad uno, en hardware real puede producir cero-uno o uno-cero con probabilidades no despreciables debido a errores de puerta y decoherencia. Cirq proporciona herramientas de caracterización de ruido que permiten medir las tasas de error de cada puerta y qubit del procesador, información esencial para diseñar circuitos que minimicen el impacto del ruido.

Para usuarios sin acceso a hardware Google, Cirq ofrece simuladores con modelos de ruido realistas que replican las características de los procesadores reales. El DensityMatrixSimulator simula la evolución cuántica incluyendo decoherencia y errores de puerta, permitiendo evaluar cómo se comportará un circuito en hardware real antes de gastar recursos de computación cuántica. Esta capacidad de simulación con ruido es especialmente valiosa durante el desarrollo, donde iterar rápidamente en un simulador local es mucho más eficiente que enviar jobs al procesador real.

Comparativa práctica: Cirq vs Qiskit vs PennyLane

La elección entre frameworks depende del objetivo. Si tu prioridad es ejecutar en hardware Google, Cirq es obligatorio. Si quieres el ecosistema más completo con la mayor comunidad, Qiskit es la opción segura. Si vienes del mundo del machine learning y quieres la transición más suave al QML, PennyLane es ideal. Los tres son open source y gratuitos, por lo que la mejor estrategia es familiarizarse con al menos dos y elegir según el proyecto específico. Para profesionales cuánticos, dominar más de un framework es una competencia diferenciadora en el mercado laboral.

Proyecto práctico: simulador de estado de Bell con Cirq

Para consolidar todo lo aprendido, construyamos un proyecto completo que genera, mide y verifica un estado de Bell con análisis estadístico de los resultados. Este proyecto combina todas las técnicas del tutorial: creación de circuitos, puertas parametrizadas, medición y análisis de resultados.

import cirq
import numpy as np

# Crear estado de Bell |Phi+> = (|00> + |11>) / sqrt(2)
q0, q1 = cirq.LineQubit.range(2)
bell = cirq.Circuit([
    cirq.H(q0),
    cirq.CNOT(q0, q1),
    cirq.measure(q0, key='q0'),
    cirq.measure(q1, key='q1')
])

# Ejecutar 10000 shots
sim = cirq.Simulator()
result = sim.run(bell, repetitions=10000)

# Analisis estadistico
q0_results = result.measurements['q0'].flatten()
q1_results = result.measurements['q1'].flatten()
correlacion = np.mean(q0_results == q1_results)

print(f"Correlacion q0-q1: {correlacion:.4f}")
print(f"Esperado: 1.0000 (siempre iguales)")
print(f"|00>: {np.mean((q0_results==0)&(q1_results==0)):.4f}")
print(f"|11>: {np.mean((q0_results==1)&(q1_results==1)):.4f}")

Este ejemplo ilustra el entrelazamiento cuántico en acción: los dos qubits están perfectamente correlacionados a pesar de medirse independientemente. En un simulador ideal, la correlación es exactamente uno (las mediciones siempre coinciden). En hardware real, la correlación será ligeramente inferior a uno debido a errores de puerta y decoherencia, proporcionando una métrica directa de la calidad del procesador cuántico.

Cirq es una herramienta poderosa que todo aspirante a programador cuántico debería dominar, especialmente si su objetivo es trabajar con el ecosistema de Google o contribuir a la investigación en computación cuántica de vanguardia. Combinado con los simuladores gratuitos, este tutorial proporciona las bases necesarias para empezar a construir aplicaciones cuánticas reales desde hoy mismo.

A medida que el ecosistema de computación cuántica siga creciendo, la capacidad de programar en Cirq y otros frameworks será cada vez más demandada en sectores como finanzas, farmacia, energía, logística y ciberseguridad. Invertir tiempo ahora en aprender estas herramientas es una apuesta con retorno garantizado para cualquier profesional técnico que quiera mantenerse relevante en la próxima década de transformación tecnológica.

<\!-- wp:html -->

<\!-- /wp:html -->