Taglio a filo per la stima dei valori attesi

Stima del tempo di esecuzione: 22 secondi su un processore Heron (NOTA: si tratta solo di una stima). (La durata potrebbe variare.)

Risultati di apprendimento

Dopo aver seguito questo tutorial, gli utenti dovrebbero aver compreso:

Come utilizzare qiskit-addon-cutting per suddividere un circuito di grandi dimensioni in sottocircuiti più piccoli, riducendo così l'effetto del rumore

Prerequisiti

Consigliamo agli utenti di acquisire familiarità con l'argomento seguente prima di seguire questo tutorial:

Utilizzando la primitiva Sampler, impiegata in questo flusso di lavoro

Sfondo

Il termine "circuito a maglie" è un concetto generico che racchiude vari metodi di suddivisione di un circuito in più sottocircuiti più piccoli, composti da un numero inferiore di porte logiche o qubit. Ciascuno dei sottocircuiti può essere eseguito in modo indipendente, e il risultato finale si ottiene mediante una classica post-elaborazione dei risultati di ciascun sottocircuito. Questa tecnica è disponibile nell'add-on "Circuit cutting" di Qiskit; per una spiegazione dettagliata della tecnica, consultare la documentazione e gli altri materiali introduttivi.

Questo tutorial si concentra su un metodo denominato " taglio del filo ", in cui il circuito viene suddiviso lungo il filo [1], [2]. Si noti che la suddivisione è semplice nei circuiti classici, poiché il risultato nel punto di suddivisione può essere determinato in modo deterministico ed è pari a 0 o 1. Tuttavia, lo stato del qubit nel momento del taglio è, in generale, uno stato misto. Pertanto, ogni sottocircuito deve essere misurato più volte in basi diverse (di solito una base tomograficamente completa, come la base di Pauli [3], [4] ) e preparato di conseguenza nel proprio stato proprio. La figura seguente (per gentile concessione di [7]) mostra un esempio di suddivisione di uno stato GHZ a quattro qubit in tre sottocircuiti. Qui $M_j$ indica un insieme di basi (di solito Pauli X, Y e Z), mentre $P_i$ indica un insieme di stati propri (di solito $|0\rangle$ , $|1\rangle$ , $|+\rangle$ e $|+i\rangle$ ).

Poiché ogni sottocircuito ha un numero inferiore di qubit e di porte logiche, ci si aspetta che siano meno sensibili al rumore. Questo tutorial illustra un esempio in cui è possibile utilizzare questo metodo per eliminare efficacemente il rumore nel sistema.

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.22 o successivamente ( pip install qiskit-ibm-runtime )
Disattivazione del circuito - Componente aggiuntivo Qiskit v0.10.0 o versioni successive (pip install qiskit-addon-cutting)
Qiskit addon utils 0.3 o versioni successive (pip install qiskit-addon-utils)
Qiskit Aer (pip install qiskit-aer )

Configura

import numpy as np
import matplotlib.pyplot as plt

from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit
from qiskit.quantum_info import PauliList, SparsePauliOp
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_aer import AerSimulator
from qiskit.result import sampled_expectation_value

from qiskit_addon_cutting.instructions import CutWire
from qiskit_addon_cutting import (
    cut_wires,
    expand_observables,
    partition_problem,
    generate_cutting_experiments,
    reconstruct_expectation_values,
)

from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2, Batch

Esempio di simulatore su piccola scala

Questo tutorial implementa un modello Qiskit per simulare un circuito di localizzazione a molti corpi (MBL) 1D e. Il circuito MBL è un circuito efficiente dal punto di vista hardware ed è parametrizzato da due parametri $\theta$ e $\vec{\phi}$ . Quando $\theta$ è impostato su $0$ e lo stato iniziale è preparato in $|0\rangle$ per tutti i qubit, il valore atteso ideale di $\langle Z_i \rangle$ è $+1$ per ogni sito di qubit $i$ indipendentemente dai valori di $\vec{\phi}$ . Maggiori dettagli su questo circuito sono disponibili in questo articolo.

Si noti che in un simulatore privo di rumore, il valore atteso ottenuto con e senza interruzione del circuito sarà lo stesso.

Fase 1: mappare gli input classici su un problema quantistico

Costruire il circuito MBL " 1D "

In primo luogo, presentiamo una funzione per la costruzione del circuito MBL ( 1D ).

class MBLChainCircuit(QuantumCircuit):
    def __init__(
        self, num_qubits: int, depth: int, use_cut: bool = False
    ) -> None:
        super().__init__(
            num_qubits, name=f"MBLChainCircuit<{num_qubits}, {depth}>"
        )
        evolution = MBLChainEvolution(num_qubits, depth, use_cut)
        self.compose(evolution, inplace=True)


class MBLChainEvolution(QuantumCircuit):
    def __init__(self, num_qubits: int, depth: int, use_cut) -> None:
        super().__init__(
            num_qubits, name=f"MBLChainEvolution<{num_qubits}, {depth}>"
        )

        theta = Parameter("θ")
        phis = ParameterVector("φ", num_qubits)

        for layer in range(depth):
            layer_parity = layer % 2
            # print("layer parity", layer_parity)
            for qubit in range(layer_parity, num_qubits - 1, 2):
                # print(qubit)
                self.cz(qubit, qubit + 1)
                self.u(theta, 0, np.pi, qubit)
                self.u(theta, 0, np.pi, qubit + 1)
                if (
                    use_cut
                    and layer_parity == 0
                    and (
                        qubit == num_qubits // 2 - 1
                        or qubit == num_qubits // 2
                    )
                ):
                    self.append(CutWire(), [num_qubits // 2])
                if use_cut and layer < depth - 1 and layer_parity == 1:
                    if qubit == num_qubits // 2:
                        self.append(CutWire(), [qubit])
            for qubit in range(num_qubits):
                self.p(phis[qubit], qubit)

num_qubits = 10
depth = 2
mbl = MBLChainCircuit(num_qubits, depth)
mbl.draw("mpl", fold=-1)

Output:

Calcoliamo il valore atteso medio $O = \frac{1}{n} \sum_i Z_i$ su tutti i qubit per $\theta = 0$ . Poiché il valore atteso ideale di $\langle Z_i \rangle = 1$ $\forall$ $i$ , anche il valore atteso ideale di $O$ è $1$ . I parametri $\phi$ sono scelti a caso.

np.random.seed(42)
phis = list(np.random.rand(mbl.num_parameters - 1))
theta = [0]
params = theta + phis

Per suddividere il circuito, è necessario inserire delle annotazioni con la dicitura " CutWire " nei punti desiderati. Per questo tutorial, abbiamo scelto una partizione equidistante. Il circuito MBL è progettato in modo tale che l'impostazione use_cut=True nella funzione inserisca correttamente l'annotazione dopo $\frac{n}{2}$ qubit, dove $n$ è il numero di qubit nel circuito originale. Abbiamo inoltre assegnato al circuito i parametri generati in modo casuale.

mbl_cut = MBLChainCircuit(num_qubits, depth, use_cut=True)
mbl_cut.assign_parameters(params, inplace=True)
mbl_cut.draw("mpl", fold=-1)

Output:

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

Taglia il circuito in sottocircuiti più piccoli

Ora suddividiamo il circuito in due sottocircuiti più piccoli utilizzando qiskit-addon-cutting. qiskit-addon-cutting aggiunge un gate virtuale Move per dividere il punto di taglio del cavo regolando opportunamente il numero di qubit. Ora creiamo il circuito con questo gate virtuale. Poiché c'è un filo tagliato, il numero di qubit associati aumenterà di 1.

mbl_move = cut_wires(mbl_cut)
mbl_move.draw("mpl", fold=-1)

Output:

Costruire ed espandere l'osservabile

L'osservabile, come definito in precedenza, sarà la media dell' $Z$ e su ciascun qubit. Tuttavia, una volta inserito il gate virtuale Move , il numero effettivo di qubit nel circuito aumenta. Anche l'osservabile deve essere esteso di conseguenza per tenere conto di questa variazione nel numero di qubit. Si noti che l'osservabile agisce sempre in modo banale (come in $I$ ) sul qubit aggiuntivo inserito per il gate virtuale Move .

observable = PauliList(
    ["I" * i + "Z" + "I" * (num_qubits - i - 1) for i in range(num_qubits)]
)
observable

Output:

PauliList(['ZIIIIIIIII', 'IZIIIIIIII', 'IIZIIIIIII', 'IIIZIIIIII',
           'IIIIZIIIII', 'IIIIIZIIII', 'IIIIIIZIII', 'IIIIIIIZII',
           'IIIIIIIIZI', 'IIIIIIIIIZ'])

new_obs = expand_observables(observable, mbl, mbl_move)
new_obs

Output:

PauliList(['ZIIIIIIIIII', 'IZIIIIIIIII', 'IIZIIIIIIII', 'IIIZIIIIIII',
           'IIIIZIIIIII', 'IIIIIIZIIII', 'IIIIIIIZIII', 'IIIIIIIIZII',
           'IIIIIIIIIZI', 'IIIIIIIIIIZ'])

Ora il circuito può essere suddiviso lungo il Move gate e si ottengono i sottocircuiti, nonché il sottoosservabile, ovvero la porzione dell'osservabile originale associata a ciascun sottocircuito.

partitioned_problem = partition_problem(circuit=mbl_move, observables=new_obs)
subcircuits = partitioned_problem.subcircuits
subobservables = partitioned_problem.subobservables

Qui riportiamo i due sottocircuiti:

subcircuits[0].draw("mpl", fold=-1)

Output:

subcircuits[1].draw("mpl", fold=-1)

Output:

Per estendere l'osservabile utilizzando l'operazione Move è necessaria una PauliList struttura dati. Per ricostruire il valore atteso del circuito originale, abbiamo bisogno dell'osservabile nel SparsePauliOp formato.

M_z = SparsePauliOp(
    ["I" * i + "Z" + "I" * (num_qubits - i - 1) for i in range(num_qubits)],
    coeffs=[1 / num_qubits] * num_qubits,
)

Come già detto, per ogni taglio il circuito a monte deve essere misurato in una base di Pauli, mentre il circuito a valle deve essere preparato nello stato proprio di tale base. La funzione generate_cutting_experiments crea tutti i circuiti necessari e i coefficienti associati a ciascun circuito richiesti per la ricostruzione. Per ulteriori dettagli, consultare questo documento.

subexperiments, coefficients = generate_cutting_experiments(
    circuits=subcircuits,
    observables=subobservables,
    num_samples=np.inf,
)

Compilare i circuiti sul backend

Per il primo esempio, che riguarda esclusivamente la simulazione, trasponiamo il circuito nell'insieme di porte di base del backend:

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

print(backend)

Output:

<IBMBackend('ibm_fez')>

Passaggio 3: eseguire utilizzando Qiskit primitives

Ora, esegui ciascun sottoesperimento:

pm_basis = generate_preset_pass_manager(
    optimization_level=2, basis_gates=backend.configuration().basis_gates
)
basis_subexperiments = {
    label: pm_basis.run(partition_subexpts)
    for label, partition_subexpts in subexperiments.items()
}

sampler = SamplerV2(mode=AerSimulator())
jobs = {
    label: sampler.run(subsystem_subexpts, shots=2**12)
    for label, subsystem_subexpts in basis_subexperiments.items()
}

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

Ora recuperiamo il risultato di ciascuna esecuzione del sottoesperimento e ricostruiamo il valore atteso del circuito non tagliato:

# Retrieve results
results = {label: job.result() for label, job in jobs.items()}

reconstructed_expval_terms = reconstruct_expectation_values(
    results,
    coefficients,
    subobservables,
)
reconstructed_expval = np.dot(reconstructed_expval_terms, M_z.coeffs).real
reconstructed_expval

Output:

np.float64(0.9953821063041687)

methods = [
    "Uncut",
    "Wire cut",
]
values = [
    1,
    reconstructed_expval,
]  # since the ideal expectation value in noiseless simulation is +1

ax = plt.gca()
plt.bar(methods, values, color="#a56eff", width=0.4, edgecolor="#8a3ffc")
ax.set_ylabel(r"$M_Z$", fontsize=12)

Output:

Text(0, 0.5, '$M_Z$')

Esempio di hardware su larga scala

Ora illustriamo il taglio dei fili per un circuito MBL da 60 qubit. Sia i circuiti non tagliati che quelli tagliati saranno realizzati su hardware dell' IBM Quantum® :

num_qubits = 60
depth = 2

# construct the circuit
mbl = MBLChainCircuit(num_qubits, depth)

# create parameters
phis = list(np.random.rand(mbl.num_parameters - 1))
theta = [0]
params = theta + phis

# construct the cut circuit
mbl_cut = MBLChainCircuit(num_qubits, depth, use_cut=True)
mbl_cut.assign_parameters(params, inplace=True)
mbl_move = cut_wires(mbl_cut)

# Define observable and expand to account for the wire cut
observable = PauliList(
    ["I" * i + "Z" + "I" * (num_qubits - i - 1) for i in range(num_qubits)]
)
new_obs = expand_observables(observable, mbl, mbl_move)

# Construct a SparsePauliOp version of the observable for later use in reconstruction
M_z = SparsePauliOp(
    ["I" * i + "Z" + "I" * (num_qubits - i - 1) for i in range(num_qubits)],
    coeffs=[1 / num_qubits] * num_qubits,
)

# Partition the circuit and get subcircuits and subobservables
partitioned_problem = partition_problem(circuit=mbl_move, observables=new_obs)
subcircuits = partitioned_problem.subcircuits
subobservables = partitioned_problem.subobservables

# Obtain subexperiments and coefficients
subexperiments, coefficients = generate_cutting_experiments(
    circuits=subcircuits,
    observables=subobservables,
    num_samples=np.inf,
)

# Transpile the subexperiments to the backend
pm = generate_preset_pass_manager(optimization_level=2, backend=backend)
isa_subexperiments = {
    label: pm.run(partition_subexpts)
    for label, partition_subexpts in subexperiments.items()
}

# Execute the subexperiments and retrieve results
with Batch(backend=backend) as batch:
    sampler = SamplerV2(mode=batch)
    sampler.options.environment.job_tags = ["TUT_WC"]
    jobs = {
        label: sampler.run(subsystem_subexpts, shots=2**12)
        for label, subsystem_subexpts in isa_subexperiments.items()
    }
results = {label: job.result() for label, job in jobs.items()}

# Reconstruct the expectation value of the original observable
reconstructed_expval_terms = reconstruct_expectation_values(
    results,
    coefficients,
    subobservables,
)
reconstructed_expval = np.dot(reconstructed_expval_terms, M_z.coeffs).real

# Compute the uncut circuit to obtain the noisy expectation value for comparison
sampler = SamplerV2(mode=backend)
sampler.options.environment.job_tags = ["TUT_WC"]

if mbl.num_clbits == 0:
    mbl.measure_all()
isa_mbl = pm.run(mbl)

pub = (isa_mbl, params)
uncut_job = sampler.run([pub])

uncut_counts = uncut_job.result()[0].data.meas.get_counts()
uncut_expval = sampled_expectation_value(uncut_counts, M_z)

# visualize the results
ax = plt.gca()
methods = ["uncut", "cut"]
values = [uncut_expval, reconstructed_expval]

plt.bar(methods, values, color="#a56eff", width=0.4, edgecolor="#8a3ffc")
plt.axhline(y=1, color="k", linestyle="--")
plt.text(0.3, 0.95, "Exact result")
plt.show()

Output:

uncut_expval

Output:

0.9202473958333336

Passi successivi

Suggerimenti

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

Riferimenti

[1] Peng, T., Harrow, A. W., Ozols, M. e Wu, X. (2020). Simulazione di grandi circuiti quantistici su un piccolo computer quantistico. Physical Review Letters, 125(15), 150504.

[2] Tang, W, Tomesh, T., Suchara, M., Larson, J. e Martonosi, M. (2021, aprile). Cutqc: utilizzo di piccoli computer quantistici per la valutazione di grandi circuiti quantistici. In Proceedings of the 26th ACM International conference on architectural support for programming languages and operating systems (pp. 473-486).

[3] Perlin, M. A., Saleem, Z. H., Suchara, M., & Osborn, J. C. (2021). Taglio di circuiti quantistici con tomografia a massima verosimiglianza. npj Quantum Information, 7(1), 64.

[4] Majumdar, R., & Wood, C. J. (2022). Taglio di circuiti quantistici mitigato dagli errori. arXiv preprint arXiv:2211.13431.

[5] Khare, T., Majumdar, R., Sangle, R., Ray, A., Seshadri, P. V. e Simmhan, Y. (2023). Parallelizzazione di carichi di lavoro quantistico-classici: Profilazione dell'impatto delle tecniche di suddivisione. In 2023 IEEE International Conference on Quantum Computing and Engineering (QCE) (Vol. 1, pp. 990-1000). IEEE.

[6] Bhoumik, D., Majumdar, R., Saha, A. e Sur-Kolay, S. (2023). Scheduling distribuito di circuiti quantistici con rumore e ottimizzazione del tempo. arXiv preprint arXiv:2309.06005.

[7] Majumdar, R. (2024). Riduzione efficiente delle risorse e del rumore nei circuiti di calcolo quantistico discreto (Tesi di dottorato, Indian Statistical Institute - Calcutta). https://www.proquest.com/openview/b481def90b1cc80e6b58a77c99e8385c/1?pq-origsite=gscholar&cbl=2026366&diss=y

Questa pagina è stata utile?

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