Corte de cables para la estimación de valores esperados

Tiempo estimado de ejecución: 22 segundos en un procesador Heron (NOTA: Se trata únicamente de una estimación). (El tiempo de ejecución puede variar.)

Resultados del aprendizaje

Una vez completado este tutorial, los usuarios deberían comprender:

Cómo utilizar qiskit-addon-cutting para dividir un circuito grande en subcircuitos más pequeños, reduciendo así el efecto del ruido

Requisitos previos

Recomendamos a los usuarios que se familiaricen con el siguiente tema antes de seguir este tutorial:

Utilizando la primitiva «Sampler», que se emplea en este flujo de trabajo

En segundo plano

El «tejido de circuitos» es un término genérico que engloba diversos métodos para dividir un circuito en varios subcircuitos más pequeños que contienen un número menor de puertas lógicas o qubits. Cada uno de los subcircuitos puede ejecutarse de forma independiente, y el resultado final se obtiene mediante un procesamiento posterior clásico del resultado de cada subcircuito. Esta técnica está disponible en el complemento «Circuit cutting» de Qiskit; consulta la documentación y otros materiales introductorios para obtener una explicación detallada de la técnica.

Este tutorial se centra en un método denominado «corte de cable», en el que el circuito se divide a lo largo del cable [1], [2]. Cabe señalar que la partición es sencilla en los circuitos clásicos, ya que el resultado en el punto de partición puede determinarse de forma determinista y es 0 o 1. Sin embargo, el estado del qubit en el momento del corte es, en general, un estado mixto. Por lo tanto, cada subcircuito debe medirse varias veces en diferentes bases (normalmente una base tomográficamente completa, como la base de Pauli [3], [4] ) y prepararse en consecuencia en su estado propio. La siguiente figura (fuente: [7] ) muestra un ejemplo de división de un estado GHZ de cuatro qubits en tres subcircuitos. Aquí, $M_j$ denota un conjunto de bases (normalmente Pauli X, Y y Z), y $P_i$ denota un conjunto de estados propios (normalmente $|0\rangle$ , $|1\rangle$ , $|+\rangle$ y $|+i\rangle$ ).

Dado que cada subcircuito tiene menos qubits y puertas lógicas, se espera que sean menos sensibles al ruido. Este tutorial muestra un ejemplo en el que se puede utilizar este método para suprimir eficazmente el ruido del sistema.

Requisitos

Antes de empezar este tutorial, asegúrate de tener instalado lo siguiente:

Qiskit SDK v2.0 o posterior, con soporte de visualización
Qiskit Runtime v0.22 o posterior ( pip install qiskit-ibm-runtime )
Complemento de diseño de circuitos de Qiskit v0.10.0 o posterior (pip install qiskit-addon-cutting)
Utilidades del complemento Qiskit: 0.3 o posterior (pip install qiskit-addon-utils)
Qiskit Aer (pip install qiskit-aer )

Configuración

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

Ejemplo de simulador a pequeña escala

Este tutorial implementa un patrón de Qiskit para simular un circuito de localización de muchos cuerpos (MBL) unidimensional ( 1D ). El circuito MBL es un circuito eficiente en cuanto a hardware y se parametriza mediante dos parámetros: $\theta$ y $\vec{\phi}$ . Cuando $\theta$ se establece en $0$ y se prepara el estado inicial en $|0\rangle$ para todos los qubits, el valor esperado ideal de $\langle Z_i \rangle$ es $+1$ para cada sitio de qubit $i$ , independientemente de los valores de $\vec{\phi}$ . En este artículo se ofrece más información sobre este circuito.

Ten en cuenta que, en un simulador sin ruido, el valor esperado obtenido con y sin corte del circuito será el mismo.

Paso 1: Asignar entradas clásicas a un problema cuántico

Construye el circuito MBL « 1D »

En primer lugar, presentamos una función para construir el 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:

Calculamos el valor esperado medio $O = \frac{1}{n} \sum_i Z_i$ para todos los qubits en $\theta = 0$ . Dado que el valor esperado ideal de $\langle Z_i \rangle = 1$ $\forall$ $i$ , el valor esperado ideal de $O$ es también $1$ . Los parámetros $\phi$ se seleccionan al azar.

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

Para dividir el circuito, hay que anotarlo insertando « CutWire » en los puntos deseados. Para este tutorial, optamos por una partición equitativa. El circuito MBL está diseñado de tal manera que, al establecer use_cut=True en la función, la anotación se inserta correctamente después de $\frac{n}{2}$ qubits, donde $n$ es el número de qubits del circuito original. También asignamos los parámetros generados aleatoriamente al circuito.

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

Output:

Paso 2: Optimizar el problema para la ejecución en hardware cuántico

Divida el circuito en subcircuitos más pequeños

Ahora dividimos el circuito en dos subcircuitos más pequeños utilizando qiskit-addon-cutting. qiskit-addon-cutting añade una puerta virtual Move para dividir el punto de corte del cable ajustando adecuadamente el número de qubits. Ahora creamos el circuito con esta puerta virtual. Dado que hay un cable cortado, el número de qubits asociados aumentará en 1.

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

Output:

Construir y ampliar el observable

La observable, tal y como se ha definido anteriormente, será la media de l $Z$ e en cada qubit. Sin embargo, al insertar la puerta virtual Move , el número efectivo de qubits del circuito aumenta. El observable también debe ampliarse en consecuencia para tener en cuenta este cambio en el número de qubits. Ten en cuenta que el observable siempre actúa de forma trivial (tal y como se describe en $I$ ) sobre el qubit adicional añadido para la puerta virtual 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'])

Ahora el circuito se puede dividir a lo largo de Move la puerta y obtenemos los subcircuitos, así como el subobservable, que es la parte del observable original asociada a cada subcircuito.

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

Aquí se muestran los dos subcircuitos:

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

Output:

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

Output:

Para ampliar el observable mediante la Move operación se necesita una PauliList estructura de datos. Para reconstruir el valor esperado del circuito original, necesitamos que la observable tenga el 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,
)

Como se ha comentado anteriormente, para cada corte, el circuito de entrada debe medirse en una base de Pauli, y el circuito de salida debe prepararse en el estado propio de dicha base. La función generate_cutting_experiments crea todos los circuitos necesarios y los coeficientes asociados a cada uno de ellos que se requieren para la reconstrucción. Encontrarás más detalles en este artículo.

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

Compilar los circuitos en el backend

En el primer ejemplo, que solo implica simulación, compilamos el circuito al conjunto de puertas básicas del backend:

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

print(backend)

Output:

<IBMBackend('ibm_fez')>

Paso 3: Ejecutar utilizando Qiskit primitives

Ahora, ejecuta cada subexperimento:

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()
}

Paso 4: Procesamiento posterior y devolución del resultado en el formato clásico deseado

Ahora recuperamos el resultado de cada ejecución del subexperimento y reconstruimos el valor esperado del circuito sin recortar:

# 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$')

Ejemplo de hardware a gran escala

A continuación, mostramos el proceso de corte de cables para un circuito MBL de 60 qubits. Tanto los circuitos sin cortar como los cortados se ejecutarán en un hardware de tip 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

Próximos pasos

Recomendaciones

Si te ha parecido interesante este trabajo, quizá te interese el siguiente material:

Referencias

[1] Peng, T., Harrow, A. W., Ozols, M., y Wu, X. (2020). Simulación de grandes circuitos cuánticos en un pequeño ordenador cuántico. Physical review letters, 125(15), 150504.

[2] Tang, W., Tomesh, T., Suchara, M., Larson, J., y Martonosi, M. (2021, abril). Cutqc: uso de pequeños ordenadores cuánticos para grandes evaluaciones de circuitos cuánticos. En 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., y Osborn, J. C. (2021). Corte de circuitos cuánticos con tomografía de máxima verosimilitud. npj Quantum Information, 7(1), 64.

[4] Majumdar, R., y Wood, C. J. (2022). Corte de circuitos cuánticos con mitigación de errores. arXiv preimpresión arXiv:2211.13431.

[5] Khare, T., Majumdar, R., Sangle, R., Ray, A., Seshadri, P. V., & Simmhan, Y. (2023). Paralelización de cargas de trabajo cuántico-clásicas: Perfiles del impacto de las técnicas de división. En 2023 IEEE International Conference on Quantum Computing and Engineering (QCE) (Vol. 1, pp. 990-1000). IEEE.

[6] Bhoumik, D., Majumdar, R., Saha, A., y Sur-Kolay, S. (2023). Programación distribuida de circuitos cuánticos con ruido y optimización del tiempo. arXiv preimpresión arXiv:2309.06005.

[7] Majumdar, R. (2024). Reducción eficiente del consumo de recursos y del ruido en circuitos de computación cuántica discreta (Tesis doctoral, Instituto Indio de Estadística - Calcuta). https://www.proquest.com/openview/b481def90b1cc80e6b58a77c99e8385c/1?pq-origsite=gscholar&cbl=2026366&diss=y

¿Le ha resultado útil esta página?

Informe de un error, de una errata o solicite contenido en GitHub.