Entanglement a lungo raggio con circuiti dinamici

Stima di utilizzo: 4 minuti su un processore Heron r2. (NOTA: questa è solo una stima. Il tempo di esecuzione può variare)

Risultati di apprendimento

Al termine di questo tutorial, avrai imparato quanto segue:

Come implementare una porta CNOT a lungo raggio utilizzando circuiti dinamici con misurazioni a metà circuito (MCM) e feedforward classico;
Come implementare il gate equivalente utilizzando un approccio unitario basato su SWAP;
Come confrontare i due approcci misurando la fedeltà del gate in funzione della distanza tra i qubit.

Prerequisiti

Consigliamo agli utenti di acquisire familiarità con i seguenti argomenti prima di seguire questo tutorial:

Concetti fondamentali dell'informatica quantistica, tra cui gli stati di Bell, l'entanglement e le porte quantistiche;
Conoscenza dei circuiti dinamici (misurazioni a metà circuito e feedforward classico);
Conoscenze di base di Qiskit SDK e del servizio IBM Quantum® Compute, nonché accesso a un account IBM Quantum.

Sfondo

L'entanglement a lungo raggio tra qubit distanti è una sfida per i dispositivi con connettività limitata. Questo tutorial mostra come i circuiti dinamici possano generare tale entanglement implementando un gate LRCX (long-range controlled-X) che utilizza un protocollo basato sulla misurazione.

Seguendo l'approccio di Elisa Bäumer et al. in 1, il metodo utilizza la misurazione a metà circuito e il feedforward per ottenere porte a profondità costante indipendentemente dalla separazione dei qubit. Crea coppie intermedie di Bell, misura un qubit da ciascuna coppia e applica porte condizionate classiche per propagare l'entanglement attraverso il dispositivo. In questo modo si evitano lunghe catene SWAP, riducendo sia la profondità del circuito che l'esposizione agli errori dei gate a due qubit.

In questo articolo adattiamo il protocollo all'hardware dell' IBM Quantum e e ne valutiamo le prestazioni in funzione della distanza tra il sistema di controllo e il bersaglio, confrontandolo con un modello di riferimento unitario basato su SWAP.

Requisiti

Prima di iniziare questa esercitazione, assicuratevi di aver installato quanto segue:

Qiskit SDK v2.0 o versioni successive, con supporto alla visualizzazione
Qiskit Runtime v0.37 o versioni successive (pip install qiskit-ibm-runtime)
Qiskit Aer v0.17 o versioni successive (pip install qiskit-aer)

Configura

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit.classical import expr
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization import plot_circuit_layout
from qiskit_ibm_runtime import (
    QiskitRuntimeService,
    Batch,
    SamplerV2 as Sampler,
)
import matplotlib.pyplot as plt
import numpy as np

Esempio di simulatore su piccola scala

Prima di eseguire il codice sulla QPU reale, verifichiamo che sia il circuito dinamico che quello unitario producano uno stato di Bell ideale su un simulatore privo di rumore. Utilizziamo l' IBM Quantum Sampler con come AerSimulator modalità di backend, a una distanza minima di 6.

Fase 1: mappare gli input classici su un problema quantistico

Ora implementiamo una porta CNOT a lungo raggio tra due qubit distanti, seguendo la costruzione del circuito dinamico illustrata di seguito (adattata dalla Fig. 1a nel rif. 1 ). L'idea fondamentale consiste nell'utilizzare un "bus" di qubit ausiliari, inizializzati a $|0\rangle$ , per mediare il teletrasporto tramite gate a lungo raggio.

Come illustrato nella figura, il processo funziona come segue:

Preparare una catena di coppie di Bell che collegano i qubit di controllo e di destinazione tramite ancillas intermedie.
Eseguire misure di Bell tra qubit vicini non entangled, scambiando l'entanglement passo dopo passo finché il controllo e il bersaglio non condividono una coppia di Bell.
Utilizzare questa coppia di Bell per il teletrasporto di porte, trasformando un CNOT locale in un CNOT deterministico a lungo raggio a profondità costante.

Questo approccio sostituisce le lunghe catene SWAP con un protocollo a profondità costante, riducendo l'esposizione agli errori dei gate a due qubit e rendendo l'operazione scalabile con le dimensioni del dispositivo.

Di seguito, illustreremo innanzitutto l'implementazione dinamica del circuito LRCX. Alla fine, forniremo anche un'implementazione unitaria di confronto, per evidenziare i vantaggi dei circuiti dinamici in questo contesto.

Inizializzare il circuito

Iniziamo con un semplice problema quantistico che fungerà da termine di paragone. Nello specifico, inizializziamo un circuito con un qubit di controllo all'indice 0 e vi applichiamo un gate di Hadamard. Ciò produce uno stato di sovrapposizione che, se seguito da un'operazione X controllata, genera uno stato di Bell $(|00\rangle + |11\rangle)/\sqrt{2}$ tra i qubit di controllo e quelli bersaglio.

In questa fase, non stiamo ancora costruendo il controllo a lungo raggio (LRCX). Il nostro obiettivo è invece quello di definire un circuito iniziale chiaro e minimale che evidenzi il ruolo della LRCX. Nella fase 2, mostreremo come l'LRCX possa essere implementato come ottimizzazione utilizzando circuiti dinamici e confronteremo le sue prestazioni con quelle di un equivalente unitario. È importante notare che il protocollo LRCX può essere applicato a qualsiasi circuito iniziale. Per chiarezza dimostrativa utilizziamo questa semplice configurazione di Hadamard.

distance = 6  # The distance of the CNOT gate, with the convention that a distance of zero is a nearest-neighbor CNOT.


def initialize_circuit(distance):
    assert distance >= 0
    control = 0  # control qubit
    n = distance  # number of qubits between target and control

    qr = QuantumRegister(
        n + 2, name="q"
    )  # Circuit with n qubits between control and target
    cr = ClassicalRegister(
        2, name="cr"
    )  # Classical register for measuring control and target qubits

    k = int(n / 2)  # Number of Bell States to be used

    allcr = [cr]
    if (
        distance > 1
    ):  # This classical register will be used to store ZZ measurements.
        # It is only used for long-range CX gates with distance > 1
        c1 = ClassicalRegister(
            k, name="c1"
        )  # Classical register needed for post processing
        allcr.append(c1)
    if (
        distance > 0
    ):  # This classical register will be used to store XX measurements.
        # It is only used if distance > 0
        c2 = ClassicalRegister(
            n - k, name="c2"
        )  # Classical register needed for post processing
        allcr.append(c2)

    qc = QuantumCircuit(qr, *allcr, name="CNOT")

    # Apply a Hadamard gate to the control qubit such that the
    # long-range CNOT gate will prepare a
    # Bell state (|00> + |11>)/sqrt(2)
    qc.h(control)

    return qc


qc = initialize_circuit(distance)
qc.draw(fold=-1, output="mpl", scale=0.5)

Output:

Fase 2: Ottimizzazione del problema per l'esecuzione su hardware quantistico

In questa fase, mostriamo come costruire il circuito LRCX utilizzando circuiti dinamici. L'obiettivo è ottimizzare il circuito per l'esecuzione su hardware riducendo la profondità rispetto a un'implementazione puramente unitaria. Per illustrare i vantaggi, mostreremo sia la costruzione LRCX dinamica che il suo equivalente unitario, per poi confrontare le loro prestazioni dopo la trasposizione. È importante notare che, mentre qui applichiamo il LRCX a un semplice problema inizializzato con Hadamard, il protocollo può essere applicato a qualsiasi circuito in cui sia richiesto un CNOT a lungo raggio.

Preparare le coppie di campane

Si inizia creando una catena di coppie di Bell lungo il percorso tra i qubit di controllo e di destinazione. Se la distanza è dispari, si applica prima un CNOT dal controllo al suo vicino, che è il CNOT che verrà teletrasportato. Per una distanza uniforme, questo CNOT verrà applicato dopo la fase di preparazione della coppia di campane. La catena di coppie di Bell aggancia quindi coppie successive di qubit, stabilendo la risorsa necessaria per trasportare le informazioni di controllo attraverso il dispositivo.

# Determine where to start the Bell pair chain and add an extra CNOT when n is odd
def check_even(n: int) -> int:
    """Return 1 if n is even, else 2."""
    return 1 if n % 2 == 0 else 2


def prepare_bell_pairs(qc, add_barriers=True):
    n = qc.num_qubits - 2  # number of qubits between target and control
    k = int(n / 2)

    if add_barriers:
        qc.barrier()

    x0 = check_even(n)
    if n % 2 != 0:
        qc.cx(0, 1)

    # Create k Bell pairs
    for i in range(k):
        qc.h(x0 + 2 * i)
        qc.cx(x0 + 2 * i, x0 + 2 * i + 1)
    return qc


qc = prepare_bell_pairs(qc)
qc.draw(output="mpl", fold=-1, scale=0.5)

Output:

Misurare coppie di qubit adiacenti nella base di Bell

Successivamente, misuriamo i qubit vicini non entangled nella base di Bell (misure a due qubit di $XX$ e $ZZ$ ). In questo modo si crea una coppia di Bell a lungo raggio tra il qubit bersaglio e il qubit adiacente al controllo (fino alle correzioni di Pauli, che saranno implementate tramite feedforward nella fase successiva). In parallelo, implementiamo la misura di entangling che teletrasporta il gate CNOT ad agire sul qubit target previsto.

def measure_bell_basis(qc, add_barriers=True):
    n = qc.num_qubits - 2  # number of qubits between target and control
    k = int(n / 2)

    if n > 1:
        _, c1, c2 = qc.cregs
    elif n > 0:
        _, c2 = qc.cregs

    # Determine where to start the Bell pair chain and add an extra CNOT
    # when n is odd
    x0 = 1 if n % 2 == 0 else 2

    # Entangling layer that implements the Bell measurement
    # (and additionally adds the CNOT to be
    # teleported, if n is even)
    for i in range(k + 1):
        qc.cx(x0 - 1 + 2 * i, x0 + 2 * i)

    for i in range(1, k + x0):
        if i == 1:
            qc.h(2 * i + 1 - x0)
        else:
            qc.h(2 * i + 1 - x0)

    if add_barriers:
        qc.barrier()

    # Map the ZZ measurements onto classical register c1
    for i in range(k):
        if i == 0:
            qc.measure(2 * i + x0, c1[i])
        else:
            qc.measure(2 * i + x0, c1[i])

    # Map the XX measurements onto classical register c2
    for i in range(1, k + x0):
        if i == 1:
            qc.measure(2 * i + 1 - x0, c2[i - 1])
        else:
            qc.measure(2 * i + 1 - x0, c2[i - 1])
    return qc


qc = measure_bell_basis(qc)
qc.draw(output="mpl", fold=-1, scale=0.5)

Output:

Applicare correzioni feedforward agli operatori dei sottoprodotti di Pauli

Le misure in base Bell introducono sottoprodotti di Pauli che devono essere corretti utilizzando i risultati registrati. Ciò avviene in due fasi. In primo luogo, è necessario calcolare la parità di tutte le misure di $ZZ$ , che viene poi utilizzata per applicare in modo condizionale un gate $X$ al qubit di destinazione. Allo stesso modo, la parità delle misure di $XX$ viene calcolata e utilizzata per applicare condizionalmente un gate $Z$ al qubit di controllo.

Con il nuovo framework di espressioni classiche di Qiskit, queste parità possono essere calcolate direttamente nel livello di elaborazione classica del circuito. Invece di applicare una sequenza di porte condizionali individuali per ogni bit di misura, possiamo costruire una singola espressione classica che rappresenta lo XOR (parità) di tutti i risultati di misura rilevanti. Questa espressione viene quindi utilizzata come condizione in un singolo blocco if_test , consentendo di applicare le porte di correzione a profondità costante. Questo approccio semplifica il circuito e garantisce che le correzioni di feedforward non introducano un'inutile latenza aggiuntiva.

def apply_ffwd_corrections(qc):
    control = 0  # control qubit
    target = qc.num_qubits - 1  # target qubit
    n = qc.num_qubits - 2  # number of qubits between target and control

    k = int(n / 2)
    x0 = check_even(n)

    if n > 1:
        _, c1, c2 = qc.cregs
    elif n > 0:
        _, c2 = qc.cregs

    # First, let's compute the parity of all ZZ measurements
    for i in range(k):
        if i == 0:
            parity_ZZ = expr.lift(
                c1[i]
            )  # Store the value of the first ZZ measurement in parity_ZZ
        else:
            parity_ZZ = expr.bit_xor(
                c1[i], parity_ZZ
            )  # Successively compute the parity via XOR operations

    for i in range(1, k + x0):
        if i == 1:
            parity_XX = expr.lift(
                c2[i - 1]
            )  # Store the value of the first XX measurement in parity_XX
        else:
            parity_XX = expr.bit_xor(
                c2[i - 1], parity_XX
            )  # Successively compute the parity via XOR operations

    if n > 0:
        with qc.if_test(parity_XX):
            qc.z(control)

    if n > 1:
        with qc.if_test(parity_ZZ):
            qc.x(target)
    return qc


qc = apply_ffwd_corrections(qc)
qc.draw(output="mpl", fold=-1, scale=0.5)

Output:

Controllo delle misure e qubit di riferimento

Definiamo una funzione helper che consente di misurare i qubit di controllo e di destinazione nelle basi $XX$ , $YY$ , o $ZZ$ . Per verificare lo stato di Bell $(|00\rangle + |11\rangle)/\sqrt{2}$ , i valori di aspettativa di $XX$ e $ZZ$ devono essere entrambi $+1$ , poiché sono stabilizzatori dello stato. La misura $YY$ è supportata anche in questo caso e verrà utilizzata di seguito per calcolare la fedeltà.

def measure_in_basis(qc, basis="XX", add_barrier=True):
    control = 0  # control qubit
    target = qc.num_qubits - 1  # target qubit

    assert basis in ["XX", "YY", "ZZ"]

    qc = (
        qc.copy()
    )  # We copy the circuit because we want to measure in different bases
    cr = qc.cregs[0]

    if add_barrier:
        qc.barrier()

    if basis == "XX":
        qc.h(control)
        qc.h(target)
    elif basis == "YY":
        qc.sdg(control)
        qc.sdg(target)
        qc.h(control)
        qc.h(target)

    qc.measure(control, cr[0])
    qc.measure(target, cr[1])
    return qc


qc_YY = measure_in_basis(qc.copy(), basis="YY")
qc_YY.draw(
    output="mpl", fold=-1, scale=0.5
)  # Circuit for measuring in the YY basis

Output:

Metti tutto insieme

Uniamo le varie fasi sopra descritte per creare un gate CX a lungo raggio alle due estremità di una linea unidimensionale ( 1D ). I passaggi sono i seguenti:

Inizializzazione del qubit di controllo in $|+\rangle$
Preparazione delle coppie di campane
Misurazione di coppie di qubit vicine
Applicazione di correzioni feedforward che dipendono dagli MCM

def lrcx(distance, prep_barrier=True, pre_measure_barrier=True):
    qc = initialize_circuit(distance)
    qc = prepare_bell_pairs(qc, prep_barrier)
    qc = measure_bell_basis(qc, pre_measure_barrier)
    qc = apply_ffwd_corrections(qc)
    return qc


qc = lrcx(distance)
# Apply the measurement in the XX, YY, and ZZ bases
qc_XX, qc_YY, qc_ZZ = [
    measure_in_basis(qc, basis=basis) for basis in ["XX", "YY", "ZZ"]
]

qc_YY.draw(
    output="mpl", fold=-1, scale=0.5
)  # Circuit for measuring in the YY basis

Output:

Implementazione unitaria con scambio dei qubit al centro

A titolo di confronto, esaminiamo innanzitutto il caso in cui una porta CNOT a lungo raggio venga implementata utilizzando connessioni tra vicini più prossimi e porte unitarie. Nella figura seguente, a sinistra è riportato un circuito per una porta CNOT a lungo raggio che copre una catena di n qubit di tipo " 1D ", in cui sono presenti solo connessioni tra vicini più prossimi. Al centro vi è una decomposizione unitaria equivalente realizzabile con porte CNOT locali; la profondità del circuito è $O(n)$ .

Il circuito al centro può essere realizzato come segue:

def cnot_unitary(distance):
    """Generate a long range CNOT gate using local CNOTs on a 1D
    chain of qubits subject to n
    nearest-neighbor connections only.


    Args:
        distance (int) : The distance of the CNOT gate,
        with the convention that
        a distance of 0 is a nearest-neighbor CNOT.

    Returns:
        QuantumCircuit: A Quantum Circuit implementing a
        long-range CNOT gate
        between qubit 0 and qubit distance+1
    """
    assert distance >= 0
    n = distance  # number of qubits between target and control

    qr = QuantumRegister(
        n + 2, name="q"
    )  # Circuit with n qubits between control and target
    cr = ClassicalRegister(
        2, name="cr"
    )  # Classical register for measuring control and target qubits

    qc = QuantumCircuit(qr, cr, name="CNOT_unitary")

    control_qubit = 0

    qc.h(control_qubit)  # Prepare the control qubit in the |+> state

    k = int(n / 2)
    qc.barrier()
    for i in range(control_qubit, control_qubit + k):
        qc.cx(i, i + 1)
        qc.cx(i + 1, i)
        qc.cx(-i - 1, -i - 2)
        qc.cx(-i - 2, -i - 1)
    if n % 2 == 1:
        qc.cx(k + 2, k + 1)
        qc.cx(k + 1, k + 2)
    qc.barrier()
    qc.cx(k, k + 1)
    for i in range(control_qubit, control_qubit + k):
        qc.cx(k - i, k - 1 - i)
        qc.cx(k - 1 - i, k - i)
        qc.cx(k + i + 1, k + i + 2)
        qc.cx(k + i + 2, k + i + 1)
    if n % 2 == 1:
        qc.cx(-2, -1)
        qc.cx(-1, -2)

    return qc


qc_uni = cnot_unitary(distance)

Ora costruisci i circuiti che effettuano misurazioni nelle basi $XX$ , $YY$ e $ZZ$ , proprio come abbiamo fatto per i circuiti dinamici sopra descritti.

# Apply the measurement in the XX, YY, and ZZ bases
qc_uni_XX, qc_uni_YY, qc_uni_ZZ = [
    measure_in_basis(qc_uni, basis=basis) for basis in ["XX", "YY", "ZZ"]
]

qc_uni_YY.draw(
    output="mpl", fold=-1, scale=0.5
)  # Circuit for measuring in the YY basis

Output:

Ora che abbiamo realizzato sia i circuiti dinamici che quelli unitari per un esempio su piccola scala con distance=6, li trasponiamo in modo che possano essere eseguiti inizialmente su un simulatore privo di rumore.

from qiskit_aer import AerSimulator

aer_backend = AerSimulator()
pm_sim = generate_preset_pass_manager(
    optimization_level=0, backend=aer_backend
)

# Dynamic circuits
isa_sim_dyn = pm_sim.run([qc_XX, qc_YY, qc_ZZ])

# Unitary circuits
isa_sim_uni = pm_sim.run([qc_uni_XX, qc_uni_YY, qc_uni_ZZ])

Passaggio 3: eseguire utilizzando Qiskit primitives

Ora possiamo eseguire l'esperimento sul backend del simulatore senza rumore. Per l'esecuzione dei circuiti utilizziamo il Sampler di Qiskit Runtime con AerSimulator come modalità di backend.

sampler_sim = Sampler(mode=aer_backend)
sim_job = sampler_sim.run(isa_sim_dyn + isa_sim_uni)
sim_results = sim_job.result()

Fase 4: Post-elaborazione e restituzione del risultato nel formato classico desiderato

Una volta che gli esperimenti sono stati eseguiti con successo, procediamo alla post-elaborazione dei dati di misurazione per ricavarne metriche significative. In questa fase, procediamo come segue:

Definire metriche di qualità per valutare le prestazioni della CX a lungo termine.
Calcolo dei valori di aspettativa degli operatori di Pauli dai risultati delle misure grezze.
Utilizzare questi dati per calcolare la fedeltà dello stato di Bell generato.

In una simulazione silenziosa, verificheremo che la metrica di fedeltà sia $1$ per i circuiti realizzati. Negli esperimenti condotti su QPU reali, questa analisi fornirà un quadro chiaro delle prestazioni dei circuiti dinamici rispetto all'implementazione unitaria di riferimento.

Metriche sulla qualità

Per valutare l'efficacia del protocollo CX a lungo raggio, misuriamo quanto lo stato di uscita si avvicini allo stato di Bell ideale. Un modo pratico per quantificarlo consiste nel calcolare la fedeltà dello stato utilizzando i valori attesi degli operatori di Pauli. È possibile calcolare la fedeltà di uno stato di Bell rispetto allo stato di controllo e a quello di riferimento una volta note le seguenti quantità: $\braket{XX}$ , $\braket{YY}$ e $\braket{ZZ}$ . In particolare,

$F = \frac{1}{4} (1 + \braket{XX} - \braket{YY} + \braket{ZZ})$

Per calcolare questi valori di aspettativa dai dati di misura grezzi, definiamo una serie di funzioni di aiuto:

compute_ZZ_expectation: Dati i conteggi delle misure, calcola il valore di aspettativa di un operatore di Pauli a due qubit nella base $Z$ .
compute_fidelity: Combina i valori di aspettativa di $XX$ , $YY$ e $ZZ$ nell'espressione di fedeltà di cui sopra.
get_counts_from_bitarray: Utilità per estrarre i conteggi dagli oggetti dei risultati del backend.

def compute_ZZ_expectation(counts):
    total = sum(counts.values())
    expectation = 0
    for bitstring, count in counts.items():
        # Ensure bitstring is 2 bits
        z1 = (-1) ** (int(bitstring[-1]))
        z2 = (-1) ** (int(bitstring[-2]))
        expectation += z1 * z2 * count
    return expectation / total


def compute_fidelity(counts_xx, counts_yy, counts_zz):
    xx, yy, zz = [
        compute_ZZ_expectation(c) for c in [counts_xx, counts_yy, counts_zz]
    ]
    return 1 / 4 * (1 + xx - yy + zz)

# Dynamic fidelity
counts_xx = sim_results[0].data.cr.get_counts()
counts_yy = sim_results[1].data.cr.get_counts()
counts_zz = sim_results[2].data.cr.get_counts()
fidelity_dyn = compute_fidelity(counts_xx, counts_yy, counts_zz)

# Unitary fidelity
counts_xx = sim_results[3].data.cr.get_counts()
counts_yy = sim_results[4].data.cr.get_counts()
counts_zz = sim_results[5].data.cr.get_counts()
fidelity_uni = compute_fidelity(counts_xx, counts_yy, counts_zz)

print(f"Dynamic fidelity (distance={distance}): {fidelity_dyn:.4f}")
print(f"Unitary fidelity (distance={distance}): {fidelity_uni:.4f}")

Output:

Dynamic fidelity (distance=6): 1.0000
Unitary fidelity (distance=6): 1.0000

Come ci si aspetterebbe in una simulazione senza rumore, le fedeltà sia nei circuiti dinamici che in quelli unitari sono pari a $1$ .

Esempio di hardware su larga scala

A questo punto riuniamo tutti questi dettagli in un unico flusso di lavoro su scala più ampia, che viene poi eseguito su hardware quantistico reale.

Generare circuiti per diverse distanze

Ora siamo in grado di generare circuiti CX a lungo raggio per una serie di distanze tra i qubit che arrivano fino a 60 qubit. Per ogni distanza, costruiamo circuiti che misurano nelle basi $XX$ , $YY$ e $ZZ$ , che verranno successivamente utilizzati per calcolare le fedeltà.

L'elenco delle distanze comprende separazioni a corto e lungo raggio, con distance = 0 che corrisponde a una CX di prossimità. Queste stesse distanze saranno utilizzate anche per generare i corrispondenti circuiti unitari in un secondo momento, a scopo di confronto.

# -------------------------Step 1-------------------------
distances = [
    0,
    1,
    2,
    3,
    6,
    11,
    16,
    21,
    28,
    35,
    44,
    55,
    60,
]  # Distances for long range CX. distance of 0 is a nearest-neighbor CX
distances.sort()
assert min(distances) >= 0
basis_list = ["XX", "YY", "ZZ"]

# Dynamic circuits
circuits_dyn = []
for distance in distances:
    for basis in basis_list:
        circuits_dyn.append(
            measure_in_basis(lrcx(distance, prep_barrier=False), basis=basis)
        )
print(f"Number of circuits: {len(circuits_dyn)}")

# Unitary circuits
circuits_uni = []
for distance in distances:
    for basis in basis_list:
        circuits_uni.append(
            measure_in_basis(cnot_unitary(distance), basis=basis)
        )

print(f"Number of circuits: {len(circuits_uni)}")

Ora che disponiamo di circuiti dinamici e unitari per una serie di distanze, siamo pronti per la trasposizione. Per prima cosa è necessario selezionare un dispositivo backend.

# -------------------------Step 2-------------------------
# Set up access to IBM Quantum devices
from qiskit.circuit import IfElseOp

service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=156
)

Il passo successivo assicura che il backend supporti l'istruzione if_else , necessaria per la nuova versione dei circuiti dinamici. Poiché questa funzione è ancora in fase di accesso anticipato, aggiungiamo esplicitamente IfElseOp al target del backend, se non è già disponibile.

if "if_else" not in backend.target.operation_names:
    backend.target.add_instruction(IfElseOp, name="if_else")

Utilizzare la stringa Layer Fidelity per selezionare una catena d' 1D

Poiché vogliamo confrontare le prestazioni dei circuiti dinamici e unitari su una catena 1D, utilizziamo la stringa Layer Fidelity per selezionare una topologia lineare della migliore catena di qubit del dispositivo. In questo modo si garantisce che entrambi i tipi di circuiti siano trasportati con gli stessi vincoli di connettività, consentendo un confronto equo delle loro prestazioni.

# This selects best qubits for longest distance and uses
# the same control for all lengths
lf_qubits = backend.properties().to_dict()[
    "general_qlists"
]  # best linear chain qubits
chosen_layouts = {
    distance: [
        val["qubits"]
        for val in lf_qubits
        if val["name"] == f"lf_{distances[-1] + 2}"
    ][0][: distance + 2]
    for distance in distances
}
print(chosen_layouts[max(distances)])  # best qubits at each distance

Output:

[11, 12, 13, 14, 15, 19, 35, 34, 33, 39, 53, 54, 55, 59, 75, 74, 73, 72, 71, 70, 69, 68, 67, 66, 65, 64, 63, 62, 61, 76, 81, 82, 83, 84, 85, 86, 87, 97, 107, 108, 109, 110, 111, 98, 91, 92, 93, 94, 95, 99, 115, 114, 113, 119, 133, 132, 131, 138, 151, 150, 149, 148]

isa_circuits_dyn = []
isa_circuits_uni = []

# Using the same initial layouts for both circuits for better
# apples to apples comparison
for qc in circuits_dyn:
    pm = generate_preset_pass_manager(
        optimization_level=1,
        backend=backend,
        initial_layout=chosen_layouts[qc.num_qubits - 2],
    )
    isa_circuits_dyn.append(pm.run(qc))

for qc in circuits_uni:
    pm = generate_preset_pass_manager(
        optimization_level=1,
        backend=backend,
        initial_layout=chosen_layouts[qc.num_qubits - 2],
    )
    isa_circuits_uni.append(pm.run(qc))

print(
    f"2Q depth: "
    f"{isa_circuits_dyn[14].depth(lambda x: x.operation.num_qubits == 2)}"
)
isa_circuits_dyn[14].draw("mpl", fold=-1, idle_wires=0)

Output:

2Q depth: 2

print(
    f"2Q depth: "
    f"{isa_circuits_uni[14].depth(lambda x: x.operation.num_qubits == 2)}"
)
isa_circuits_uni[14].draw("mpl", fold=-1, idle_wires=False)

Output:

2Q depth: 13

Visualizza i qubit utilizzati per il circuito LRCX

In questa sezione esaminiamo come il circuito LRCX viene mappato sull'hardware. Iniziamo con la visualizzazione dei qubit fisici utilizzati nel circuito e poi studiamo come la distanza controllo-target nel layout influisce sul numero di operazioni.

# Note: the qubit coordinates must be hard-coded.
# The backend API does not currently provide this information directly.
# If using a different backend, you will need to
# adjust the coordinates accordingly,
# or set the qubit_coordinates = None to use the default layout coordinates.


def _heron_coords_r2():
    """Generate coordinates for the Heron layout in R2. Note"""
    cord_map = np.array(
        [
            [
                0,
                1,
                2,
                3,
                4,
                5,
                6,
                7,
                8,
                9,
                10,
                11,
                12,
                13,
                14,
                15,
                3,
                7,
                11,
                15,
                0,
                1,
                2,
                3,
                4,
                5,
                6,
                7,
                8,
                9,
                10,
                11,
                12,
                13,
                14,
                15,
                1,
                5,
                9,
                13,
                0,
                1,
                2,
                3,
                4,
                5,
                6,
                7,
                8,
                9,
                10,
                11,
                12,
                13,
                14,
                15,
                3,
                7,
                11,
                15,
                0,
                1,
                2,
                3,
                4,
                5,
                6,
                7,
                8,
                9,
                10,
                11,
                12,
                13,
                14,
                15,
                1,
                5,
                9,
                13,
                0,
                1,
                2,
                3,
                4,
                5,
                6,
                7,
                8,
                9,
                10,
                11,
                12,
                13,
                14,
                15,
                3,
                7,
                11,
                15,
                0,
                1,
                2,
                3,
                4,
                5,
                6,
                7,
                8,
                9,
                10,
                11,
                12,
                13,
                14,
                15,
                1,
                5,
                9,
                13,
                0,
                1,
                2,
                3,
                4,
                5,
                6,
                7,
                8,
                9,
                10,
                11,
                12,
                13,
                14,
                15,
                3,
                7,
                11,
                15,
                0,
                1,
                2,
                3,
                4,
                5,
                6,
                7,
                8,
                9,
                10,
                11,
                12,
                13,
                14,
                15,
            ],
            -1
            * np.array([j for i in range(15) for j in [i] * [16, 4][i % 2]]),
        ],
        dtype=int,
    )

    hcords = []
    ycords = cord_map[0]
    xcords = cord_map[1]
    for i in range(156):
        hcords.append([xcords[i] + 1, np.abs(ycords[i]) + 1])

    return hcords


# Visualize the active qubits in the circuit layout
plot_circuit_layout(
    circuit=isa_circuits_uni[-1],
    backend=backend,
    view="physical",
    qubit_coordinates=_heron_coords_r2(),
)

Output:

Successivamente, eseguiamo l'esperimento sul backend reale. Utilizziamo inoltre il batching per eseguire l'esperimento in modo efficiente su più prove. L'esecuzione di prove ripetute ci consente di calcolare le medie per un confronto più accurato tra il metodo unitario e quello dinamico, nonché di quantificarne la variabilità confrontando le deviazioni tra le diverse esecuzioni.

# -------------------------Step 3-------------------------
num_trials = 10
jobs_uni = []
jobs_dyn = []
with Batch(backend=backend) as batch:
    sampler = Sampler(mode=batch)
    sampler.options.environment.job_tags = ["TUT_LRE"]
    for _ in range(num_trials):
        jobs_uni.append(sampler.run(isa_circuits_uni, shots=1024))
        jobs_dyn.append(sampler.run(isa_circuits_dyn, shots=1024))

Calcoliamo la fedeltà dei circuiti CX dinamici a lungo raggio. Per ciascuna distanza, estraiamo i risultati delle misurazioni nei database $\braket{XX}$ , $\braket{YY}$ e $\braket{ZZ}$ . Questi risultati vengono combinati utilizzando le funzioni di supporto definite in precedenza per calcolare la fedeltà secondo $F = \tfrac{1}{4} \big( 1 + \langle XX \rangle - \langle YY \rangle + \langle ZZ \rangle \big)$ . Ciò fornisce la fedeltà osservata del protocollo eseguito dinamicamente a ciascuna distanza.

# -------------------------Step 4-------------------------
fidelities_dyn = []

# loop over trials
for job in jobs_dyn:
    result_dyn = job.result()
    trial_fidelities = []
    # loop over all distances
    for ind, dist in enumerate(distances):
        counts_xx = result_dyn[ind * 3].data.cr.get_counts()
        counts_yy = result_dyn[ind * 3 + 1].data.cr.get_counts()
        counts_zz = result_dyn[ind * 3 + 2].data.cr.get_counts()
        trial_fidelities.append(
            compute_fidelity(counts_xx, counts_yy, counts_zz)
        )
    fidelities_dyn.append(trial_fidelities)
# average over trials for each distance
avg_fidelities_dyn = np.mean(fidelities_dyn, axis=0)
std_fidelities_dyn = np.std(fidelities_dyn, axis=0)

Ora calcoliamo la fedeltà per i circuiti CX unitari a lungo raggio e lo facciamo nello stesso modo in cui abbiamo fatto per i circuiti dinamici di cui sopra.

fidelities_uni = []

# loop over trials
for job in jobs_uni:
    result_uni = job.result()
    trial_fidelities = []
    # loop over all distances
    for ind, dist in enumerate(distances):
        counts_xx = result_uni[ind * 3].data.cr.get_counts()
        counts_yy = result_uni[ind * 3 + 1].data.cr.get_counts()
        counts_zz = result_uni[ind * 3 + 2].data.cr.get_counts()
        trial_fidelities.append(
            compute_fidelity(counts_xx, counts_yy, counts_zz)
        )
    fidelities_uni.append(trial_fidelities)
# average over trials for each distance
avg_fidelities_uni = np.mean(fidelities_uni, axis=0)
std_fidelities_uni = np.std(fidelities_uni, axis=0)

Traccia i risultati

Per comprendere meglio i risultati dal punto di vista visivo, il grafico sottostante illustra le fedeltà di gate stimate, misurate a diverse distanze tra i qubit intrecciati per ciascun metodo.

fig, ax = plt.subplots()

# Unitary with error bars
ax.errorbar(
    distances,
    avg_fidelities_uni,
    yerr=std_fidelities_uni,
    fmt="o-.",
    color="c",
    ecolor="c",
    elinewidth=1,
    capsize=4,
    label="Unitary",
)
# Dynamic with error bars
ax.errorbar(
    distances,
    avg_fidelities_dyn,
    yerr=std_fidelities_dyn,
    fmt="o-.",
    color="m",
    ecolor="m",
    elinewidth=1,
    capsize=4,
    label="Dynamic",
)
# Random gate baseline
ax.axhline(y=1 / 4, linestyle="--", color="gray", label="Random gate")

legend = ax.legend(frameon=True)
for text in legend.get_texts():
    text.set_color("black")
legend.get_frame().set_facecolor("white")
legend.get_frame().set_edgecolor("black")
ax.set_title(
    "Bell State Fidelity vs Control–Target Separation", color="black"
)
ax.set_xlabel("Distance", color="black")
ax.set_ylabel("Bell state fidelity", color="black")
ax.grid(linestyle=":", linewidth=0.6, alpha=0.4, color="gray")
ax.set_ylim((0.2, 1))
ax.set_facecolor("white")
fig.patch.set_facecolor("white")
for spine in ax.spines.values():
    spine.set_visible(True)
    spine.set_color("black")
ax.tick_params(axis="x", colors="black")
ax.tick_params(axis="y", colors="black")
plt.show()

Output:

Dal grafico di fedeltà sopra riportato, l'LRCX non ha superato in modo consistente l'implementazione unitaria diretta. In effetti, per brevi separazioni controllo-bersaglio, il circuito unitario ha ottenuto una maggiore fedeltà. Tuttavia, a separazioni maggiori, il circuito dinamico inizia a ottenere una migliore fedeltà rispetto all'implementazione unitaria. Questo comportamento non è inaspettato sull'hardware attuale: se da un lato i circuiti dinamici riducono la profondità del circuito evitando lunghe catene di SWAP, dall'altro introducono un tempo di circuito aggiuntivo dovuto alle misure a metà circuito, al feedforward classico e ai ritardi del percorso di controllo. La latenza aggiunta aumenta la decoerenza e gli errori di lettura, che possono superare il risparmio di profondità a brevi distanze.

Tuttavia, osserviamo un punto di incrocio in cui l'approccio dinamico supera quello unitario. Questo è un risultato diretto della diversa scala: la profondità del circuito unitario cresce linearmente con la distanza tra i qubit, mentre la profondità del circuito dinamico rimane costante.

Punti chiave:

Vantaggi immediati dei circuiti dinamici: La principale motivazione attuale è la riduzione della profondità dei due qubit, non necessariamente una maggiore fedeltà.
Perché la fedeltà può essere peggiore oggi: L'aumento del tempo di circuito dovuto alle operazioni di misura e classiche spesso domina, soprattutto quando la separazione controllo-obiettivo è piccola.
In prospettiva: Con il miglioramento dell'hardware, in particolare con una lettura più veloce, una latenza di controllo classica più breve e una riduzione dell'overhead del circuito centrale, dovremmo aspettarci che queste riduzioni di profondità e durata si traducano in guadagni di fedeltà misurabili.

# Compute metrics for each distance, skipping the basis circuits since
# they are identical for each distance
depths_2q_dyn = [
    c.depth(lambda x: x.operation.num_qubits == 2)
    for c in isa_circuits_dyn[::3]
]
meas_dyn = [
    sum(1 for instr in c.data if instr.operation.name == "measure")
    for c in isa_circuits_dyn[::3]
]

depths_2q_uni = [
    c.depth(lambda x: x.operation.num_qubits == 2)
    for c in isa_circuits_uni[::3]
]
meas_uni = [
    sum(1 for instr in c.data if instr.operation.name == "measure")
    for c in isa_circuits_uni[::3]
]

fig, axes = plt.subplots(1, 2, figsize=(12, 5))

axes[0].plot(
    distances, depths_2q_uni, "o-.", color="c", label="Unitary (2Q depth)"
)
axes[0].plot(
    distances, depths_2q_dyn, "o-.", color="m", label="Dynamic (2Q depth)"
)
axes[0].set_xlabel("Number of qubits between control and target")
axes[0].set_ylabel("Two-qubit depth")
axes[0].grid(True, linestyle=":", linewidth=0.6, alpha=0.4)
axes[0].legend()

axes[1].plot(
    distances, meas_uni, "o-.", color="c", label="Unitary (# measurements)"
)
axes[1].plot(
    distances, meas_dyn, "o-.", color="m", label="Dynamic (# measurements)"
)
axes[1].set_xlabel("Number of qubits between control and target")
axes[1].set_ylabel("Number of measurements")
axes[1].grid(True, linestyle=":", linewidth=0.6, alpha=0.4)
axes[1].legend()

fig.suptitle("Scaling of Unitary vs Dynamic LRCX with Distance", fontsize=12)

plt.tight_layout()
plt.show()

Output:

Questo grafico della profondità dei due qubit evidenzia il vantaggio principale dell'LRCX implementato con circuiti dinamici: le prestazioni rimangono essenzialmente costanti all'aumentare della separazione tra i qubit di controllo e quelli di destinazione. Al contrario, l'implementazione unitaria cresce linearmente con la distanza a causa delle catene SWAP necessarie. La profondità cattura lo scaling logico delle operazioni a due qubit, mentre il conteggio delle misure riflette l'overhead aggiuntivo per i circuiti dinamici. Queste misure sono efficienti, poiché vengono eseguite in parallelo, ma introducono comunque un costo fisso sull'hardware odierno.

Perché la fedeltà può essere peggiore oggi: L'aumento del tempo di circuito dovuto alle operazioni di misura e classiche spesso domina, soprattutto quando la separazione controllo-obiettivo è piccola. Ad esempio, la lunghezza media di lettura di un processore Heron r2 è di 2.280 ns, mentre la lunghezza del gate 2Q è di soli 68 ns.

Con il miglioramento delle latenze di misura e classiche, ci aspettiamo che la scalatura a profondità costante e a misurazione costante dei circuiti dinamici produca chiari vantaggi in termini di fedeltà e di tempo di esecuzione su circuiti più grandi.

Passi successivi

Se questo lavoro ti è sembrato interessante, potrebbero interessarti anche i seguenti materiali:

Suggerimenti

Riferimenti

[1] Entanglement efficiente a lungo raggio con circuiti dinamici, di Elisa Bäumer, Vinay Tripathi, Derek S. Wang, Patrick Rall, Edward H. Chen, Swarnadeep Majumder, Alireza Seif, Zlatko K. Minev. IBM Quantum, (2023). https://arxiv.org/abs/2308.13065

Questa pagina è stata utile?

Segnala un bug, un errore di battitura o richiedi contenuti su GitHub.