Corrección de errores cuánticos con estabilizadores

La corrección de errores cuánticos es un aspecto crucial en el escalado de ordenadores cuánticos para poder aprovechar la ventaja cuántica y desarrollar algoritmos de manera fiable.

Los principales tipos de errores son el error de inversión de bit, que altera el estado de un qubit de a (y viceversa), el error de inversión de fase, que invierte la fase del qubit, por ejemplo de a , y combinaciones de ambos.

En un circuito cuántico los errores pueden ocurrir en:

• Error en las transformaciones o puertas: Errores en las transformaciones realizadas por las puertas, que se caracterizan por la fidelidad.
• Errores de decoherencia: Cuando un qubit interactúa con el entorno.
• Errores en la medida: Errores en el proceso de medida clásica.
• Errores de crosstalk: Interacciones con qubits físicamente próximos.

A continuación, vamos a ver un ejemplo de corrección de errores cuánticos con estabilizadores. Para ello se crea redundancia en el estado proyectándolo en un espacio de dimensión superior llamado espacio de código y se pasa este estado por un canal ruidoso que produce un error.

Para detectar y corregir los errores se utiliza el subgrupo de estabilizadores, que es un subgrupo del grupo de Pauli con generadores que anti-conmutan con los errores que quiero detectar y dejan el espacio de código invariante. En este proceso de extracción, con cada generador se obtiene cada tipo de error base y si hay k generadores del subgrupo de estabilizadores, se podrán detectar diferentes errores, uno por cada síndrome menos el síndrome con todo 0 que se corresponde a la ausencia de error.

Primero, importamos las librerías necesarias, definimos un registro de 3 qubits de datos y un registro de 2 qubits de ancila para los estabilizadores.

import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit_aer import AerSimulator

# 1. Definición de Registros (3 cúbits de datos, 2 cúbits ancila para estabilizadores)
data_reg = QuantumRegister(3, name='data')
ancilla_reg = QuantumRegister(2, name='ancilla')
syndrome_reg = ClassicalRegister(2, name='syndrome')
measure_reg = ClassicalRegister(3, name='measure')

circuit = QuantumCircuit(data_reg, ancilla_reg, syndrome_reg, measure_reg)

Ahora, preparamos el estado inicial , generamos redundancia para crear el espacio de código y aplicamos un error de inversión de bit en el qubit 1.

# 2. Estado Inicial: Preparar el cúbit de datos 0 en el estado |1> como prueba
circuit.x(data_reg[0])
circuit.barrier()

# 3. Codificación: Crear el estado entrelazado |111> (Repetition Code)
circuit.cx(data_reg[0], data_reg[1])
circuit.cx(data_reg[0], data_reg[2])
circuit.barrier()

# 4. Inyección del Error: Simulamos un error X en el cúbit de datos 1
# Cambia el índice para probar el comportamiento con otros cúbits
circuit.x(data_reg[1])
circuit.barrier()

Luego, aplicamos dos estabilizadores para detectar diferencias entre el valor de los qubits, entre el qubit 0 y 1 y entre el qubit 1 y 2, y medimos el síndrome. Esto permitirá detectar con éxito cualquier error de inversión de bit en un único qubit, es decir un total de 3 errores.

# 5. Generadores de Estabilizadores: Medición de Z_0 Z_1 y Z_1 Z_2
# Estabilizador 1: Z_0 Z_1 (Detecta diferencias entre cúbit 0 y 1)
circuit.cx(data_reg[0], ancilla_reg[0])
circuit.cx(data_reg[1], ancilla_reg[0])

# Estabilizador 2: Z_1 Z_2 (Detecta diferencias entre cúbit 1 y 2)
circuit.cx(data_reg[1], ancilla_reg[1])
circuit.cx(data_reg[2], ancilla_reg[1])

# Medición del síndrome de error
circuit.measure(ancilla_reg, syndrome_reg)
circuit.barrier()

Por último, en función del síndrome detectado, corregimos los errores, hacemos la medición final y la simulación.

# 6. Corrección de Errores (Lógica del Síndrome basada en la medición)
# Síndrome '01' (en binario Qiskit: ancilla 1 es 0, ancilla 0 es 1) -> Error en cúbit 0
with circuit.if_test((syndrome_reg, 1)):
    circuit.x(data_reg[0])

# Síndrome '11' (ancilla 1 es 1, ancilla 0 es 1) -> Error en cúbit 1
with circuit.if_test((syndrome_reg, 3)):
    circuit.x(data_reg[1])

# Síndrome '10' (ancilla 1 es 1, ancilla 0 es 0) -> Error en cúbit 2
with circuit.if_test((syndrome_reg, 2)):
    circuit.x(data_reg[2])

circuit.barrier()

# 7. Medición Final de los cúbits de datos para verificar la corrección
circuit.measure(data_reg, measure_reg)

# 8. Ejecución en el Simulador
simulator = AerSimulator()
compiled_circuit = qiskit.transpile(circuit, simulator)
result = simulator.run(compiled_circuit, shots=1000).result()
counts = result.get_counts()

print("Resultados de la medición (Formato: 'medición_datos síndrome'):")
print(counts)

La simulación de los datos devuelve ‘111’, que es el estado corregido, y el síndrome devuelve ’11’. Al ser el síndrome ’11’, el bloque condicional with circuit.if_test((syndrome_reg, 3)): detecta el valor entero 3 y ejecuta una compuerta de corrección X sobre el cúbit data[1], que es donde estaba el error.

Resultados de la medición (Formato: 'medición_datos síndrome'):
{'111 11': 1000}