Crear un gestor de pases para el desacoplamiento dinámico

• Versiones del paquete

  El código de esta página se ha desarrollado teniendo en cuenta los siguientes requisitos. Recomendamos utilizar estas versiones o versiones más recientes.

  qiskit[all]~=2.5.0
  qiskit-ibm-runtime~=0.47.0
  

Esta página muestra cómo utilizar el PadDynamicalDecoupling pass para añadir al circuito una técnica de supresión de errores llamada desacoplamiento dinámico.

El desacoplamiento dinámico funciona añadiendo secuencias de pulsos (conocidas como secuencias de desacoplamiento dinámico ) a los qubits inactivos para voltearlos alrededor de la esfera de Bloch, lo que anula el efecto de los canales de ruido, suprimiendo así la decoherencia. Estas secuencias de impulsos son similares a los impulsos de reenfoque utilizados en resonancia magnética nuclear. Para una descripción completa, véase A Quantum Engineer's Guide to Superconducting Qubits.

Debido a que el pase PadDynamicalDecoupling sólo opera en circuitos programados e involucra compuertas que no son necesariamente compuertas de base de nuestro objetivo, necesitará los parámetros ALAPScheduleAnalysis y BasisTranslator también.

Obtén la target información del backend y guarda los nombres de las operaciones como, ya basis_gates que target habrá que modificar el para añadir información de temporización de las puertas utilizadas en el desacoplamiento dinámico.

from qiskit_ibm_runtime.fake_provider import FakeSherbrooke

backend = FakeSherbrooke()

target = backend.target
basis_gates = list(target.operation_names)

Cree un circuito efficient_su2 a modo de ejemplo. En primer lugar, transpile el circuito al backend, ya que es necesario añadir pulsos de desacoplamiento dinámico después de transpilar y programar el circuito. El desacoplamiento dinámico suele funcionar mejor cuando hay mucho tiempo de inactividad en los circuitos cuánticos, es decir, cuando hay qubits que no se utilizan mientras otros están activos. Este es el caso en este circuito porque las puertas ecr de dos qubits se aplican secuencialmente en este ansatz.

from qiskit.transpiler import generate_preset_pass_manager
from qiskit.circuit.library import efficient_su2

qc = efficient_su2(12, entanglement="circular", reps=1)
pm = generate_preset_pass_manager(1, target=target, seed_transpiler=12345)
qc_t = pm.run(qc)
qc_t.draw("mpl", fold=-1, idle_wires=False)

Output:

Una secuencia de desacoplamiento dinámico es una serie de puertas que componen a la identidad y están espaciadas regularmente en el tiempo. Por ejemplo, comience creando una secuencia simple llamada XY4 que conste de cuatro puertas.

from qiskit.circuit.library import XGate, YGate

X = XGate()
Y = YGate()

dd_sequence = [X, Y, X, Y]

Debido a la periodicidad de las secuencias de desacoplamiento dinámico, la información sobre el YGate debe añadirse al, target ya que no es una puerta básica, mientras que el XGate sí lo es. Sabemos a priori que el YGate tiene la misma duración y error que el XGate, sin embargo, podemos recuperar esas propiedades del target y añadirlas de nuevo a los YGate objetos. Esta es también la razón por la que basis_gates se guardaron por separado, ya que estamos añadiendo la YGate instrucción a, target aunque no sea una puerta básica real de ibm_fez.

from qiskit.transpiler import InstructionProperties

y_gate_properties = {}
for qubit in range(target.num_qubits):
    y_gate_properties.update(
        {
            (qubit,): InstructionProperties(
                duration=target["x"][(qubit,)].duration,
                error=target["x"][(qubit,)].error,
            )
        }
    )

target.add_instruction(YGate(), y_gate_properties)

Los circuitos Ansatz como efficient_su2 están parametrizados, por lo que deben tener un valor vinculado a ellos antes de ser enviados al backend. Aquí, asigna parámetros aleatorios.

import numpy as np

rng = np.random.default_rng(1234)
qc_t.assign_parameters(
    rng.uniform(-np.pi, np.pi, qc_t.num_parameters), inplace=True
)

A continuación, ejecute los pases personalizados. Instancie PassManager con ALAPScheduleAnalysis y PadDynamicalDecoupling. Ejecute ALAPScheduleAnalysis primero para añadir información de temporización sobre el circuito cuántico antes de que se puedan añadir las secuencias de desacoplamiento dinámico regularmente espaciadas. Estas pasadas se realizan en el circuito con .run().

from qiskit.transpiler import PassManager
from qiskit.transpiler.passes.scheduling import (
    ALAPScheduleAnalysis,
    PadDynamicalDecoupling,
)

dd_pm = PassManager(
    [
        ALAPScheduleAnalysis(target=target),
        PadDynamicalDecoupling(target=target, dd_sequence=dd_sequence),
    ]
)
qc_dd = dd_pm.run(qc_t)

Utilice la herramienta de timeline_drawer visualización para ver la sincronización del circuito y confirmar que aparece una secuencia espaciada regularmente de XGate objetos y YGate objetos en el circuito.

from qiskit.visualization import timeline_drawer

timeline_drawer(qc_dd, idle_wires=False, target=target)

Output:

Por último, dado que YGate no es una puerta base real de nuestro backend, aplique manualmente el pase BasisTranslator (es un pase predeterminado, pero se ejecuta antes de la programación, por lo que es necesario aplicarlo de nuevo). La biblioteca de equivalencias de sesión es una biblioteca de equivalencias de circuitos que permite al transpilador descomponer circuitos en puertas base, como también se especifica como argumento.

from qiskit.circuit.equivalence_library import (
    SessionEquivalenceLibrary as sel,
)
from qiskit.transpiler.passes import BasisTranslator

qc_dd = BasisTranslator(sel, basis_gates)(qc_dd)
qc_dd.draw("mpl", fold=-1, idle_wires=False)

Output:

Ahora, YGate los objetos están ausentes de nuestro circuito, y hay información de sincronización explícita en forma de Delay puertas. Este circuito transpilado con desacoplamiento dinámico ya está listo para enviarse al backend.

Próximos pasos