Simulación de sistemas cuánticos con ruido mediante la propagación de Pauli

En esta guía utilizamos el paquete pauli-prop para simular de forma clásica la dinámica temporal de un modelo de Ising de campo transversal (TFIM) de nueve qubits con ruido en una red cuadrada de 3x3. Utilizamos las instrucciones de « PauliLindbladError » para definir un canal de ruido, $\Lambda$ , que actúa sobre un conjunto de capas de entrelazamiento, $\mathcal{U}$ . A continuación, propagamos el observable, $O$ , hacia atrás a través del circuito con ruido y estimamos los valores esperados para diversos modelos de ruido, así como para el caso sin ruido.

A medida que la variable observable se propaga hacia atrás a través del circuito, cada canal de ruido, $\Lambda_k$ , asociado a la capa de entrelazamiento, $\mathcal{U}_k$ , amortigua los términos de Pauli en $O$ que anticomutan con sus generadores de Pauli-Lindblad. Concretamente, si $G_{k,i}$ es un generador de Pauli de $\Lambda_k$ con tasa $\gamma_{k,i}$ , entonces un término de Pauli, $P$ , en $O$ se transforma como: $c_P \mapsto c_P e^{-2\gamma_{k,i}} \quad \text{if } \{P, G_{k,i}\}=0$ , donde $c_P$ es el coeficiente de $P$ . Una vez que $O$ se ha propagado hasta el principio del circuito, el valor esperado con respecto al estado cero, $|0\rangle^{\otimes N}$ , puede calcularse de forma trivial sumando los coeficientes de cada término diagonal en $O$ (términos que contienen $Z$ o $I$ en todos los qubits).

Flujo de trabajo:

Especifica la red TFIM y utiliza la coloración de aristas para identificar un conjunto mínimo de capas entrelazadas
Generar modelos de ruido sintético, $\Lambda_k$ $Λ_{k}$ , para cada capa de entrelazamiento única, $U_k$ $U_{k}$
- Crear modelos de ruido a distintas escalas para estudiar el impacto del ruido de las compuertas en el sistema
Crear circuitos cuánticos sin ruido y con ruido para las distintas profundidades y escalas de ruido de interés
- En los circuitos con ruido, se insertan instrucciones PauliLindbladError antes de cada capa de entrelazamiento
Utiliza la propagación de Pauli para simular los valores exactos de la esperanza del sistema a distintas profundidades
- En el caso de nueve qubits, esto se consigue dejando que « $O$ » crezca hasta incluir términos de « $4^9$ », cubriendo así todo el espacio de Pauli
Utiliza la propagación de Pauli para simular valores esperados con ruido
Observa cómo el aumento del ruido de la puerta degrada la precisión del modelo cuántico

Genera una red cuadrada de 3x3 y busca una coloración de 4 colores en las aristas

Los vértices del grafo representan qubits, y las aristas representan una conexión entre dos qubits. El color de los bordes corresponde a capas de entrelazamiento únicas en el circuito cuántico, de modo que las puertas situadas en conexiones asociadas a colores diferentes no pueden aplicarse simultáneamente.

A menudo resulta importante identificar un conjunto mínimo de capas de entrelazamiento únicas para implementar protocolos eficientes de aprendizaje del ruido, ya que el ruido de cada capa debe aprenderse de forma independiente. Cuantas más capas tengamos que aprender, más capturas tendremos que realizar desde la QPU. Para esta demostración, utilizamos la información de las capas para construir circuitos con ruido e inyectamos instrucciones « PauliLindbladError » antes qiskit-aer de cada capa de entrelazamiento, con el fin de modelar el ruido de las puertas de la QPU.

from collections import defaultdict

import numpy as np
from qiskit.transpiler import CouplingMap
from qiskit_addon_utils.coloring import auto_color_edges

# Define rectangular square-lattice on 20 qubits
num_rows = 3
num_cols = 3
num_qubits = num_rows * num_cols

coupling_map = CouplingMap.from_grid(
    num_rows=num_rows, num_columns=num_cols, bidirectional=False
)

# Create mapping from color to edge list
coloring = auto_color_edges(coupling_map.get_edges())
color_to_edge = defaultdict(list)
for edge, color in coloring.items():
    color_to_edge[color].append(edge)

from rustworkx import PyDiGraph
from rustworkx.visualization import graphviz_draw

# Inspect graph coupling and unique entangling layers
print(
    f"The circuit will have {num_qubits} qubits and {len(color_to_edge)} unique entangling layers."
)
sq_lattice = PyDiGraph()
sq_lattice.extend_from_weighted_edge_list(
    [
        (source, target, color)
        for ((source, target), color) in coloring.items()
    ]
)


def color_edge_4color(edge):
    color_dict = {0: "red", 1: "green", 2: "blue", 3: "orange"}
    return {"color": color_dict[edge]}


graphviz_draw(sq_lattice, edge_attr_fn=color_edge_4color, method="neato")

Output:

The circuit will have 9 qubits and 4 unique entangling layers.

Generar modelos de ruido sintético

Antes de crear los circuitos cuánticos, generamos un modelo de ruido (una instancia de PauliLindbladError ) para cada una de las capas de entrelazamiento. Más adelante las incorporaremos como instrucciones en nuestros circuitos cuánticos. Para cada capa, generamos canales de ruido de distintas escalas. En concreto, generamos modelos de ruido con un error por puerta por capa (EPLG) de aproximadamente .0004, .0008, .0012, .0016, y .002.

from qiskit.quantum_info import SparsePauliOp, pauli_basis
from qiskit_aer.noise import PauliLindbladError

# Pauli-Lindblad noise parameters
seed = 1764
target_EPLGs = [0.0004, 0.0008, 0.0012, 0.0016, 0.002]


def generate_random_pauli_lindblad_noise(
    edges,
    num_qubits: int | None = None,
    noise_scale: float = 1e-3,
    seed: int | None = None,
) -> PauliLindbladError:
    """Generate random Pauli-Lindblad noise over the full Pauli basis."""
    if num_qubits is None:
        num_qubits = np.max(edges)

    basis_paulis = [p for p in pauli_basis(2) if np.sum(p.x + p.z)]
    basis_paulis = SparsePauliOp.from_sparse_list(
        [
            (pauli.to_label(), edge, 1)
            for pauli in basis_paulis
            for edge in edges
        ],
        num_qubits=num_qubits,
    )
    basis_paulis = basis_paulis.simplify()
    basis_paulis = basis_paulis.paulis

    rng = np.random.default_rng(seed=seed)
    rates = rng.random(len(basis_paulis)) * noise_scale

    return PauliLindbladError(generators=basis_paulis, rates=rates)


num_generators = (
    (num_rows * num_cols)
    + (num_rows - 1) * num_cols
    + num_rows * (num_cols - 1)
)
noise_scales = [
    EPLG * (num_rows * num_cols) / num_generators for EPLG in target_EPLGs
]
noise_models_per_EPLG = [
    [
        generate_random_pauli_lindblad_noise(
            color_to_edge[color],
            num_qubits=num_qubits,
            noise_scale=noise_scale,
            seed=seed,
        )
        for color in range(len(color_to_edge))
    ]
    for noise_scale in noise_scales
]

Crear los circuitos cuánticos

En esta demostración, simulamos la dinámica temporal de un modelo de Ising de campo transversal (TFIM) para un número creciente de pasos de Trotter (de 1 a 10 pasos). Para cada una de las 10 profundidades del circuito, simulamos el efecto del ruido de puerta, partiendo de modelos de ruido de distintas escalas (EPLGs = .0004, .0008, .0012, .0016, .002). El ruido se inserta en el circuito QuantumCircuit mediante una instrucción « PauliLindbladError » de Qiskit Aer. El hamiltoniano que se considera es:

$H = -J\sum\limits_{\langle i,j \rangle} Z_iZ_j + h\sum\limits_iX_i$

donde $J>0$ describe el acoplamiento entre los espines más próximos, $i<j$ , y $h$ es el campo transversal global.

Aquí aplicamos el hamiltoniano evolucionado en el tiempo a diversas escalas de tiempo y de ruido. Creamos un total de 60 circuitos: 10 circuitos sin ruido que varían en cuanto a la profundidad de Trotter, y 50 circuitos con ruido para las 10 profundidades de Trotter, distribuidos en cinco escalas de ruido. Dado un grafo de conectividad, el modelo se parametriza mediante unas pocas variables:

num_steps: El número de pasos de Trotter
J: Fuerza de acoplamiento de los sitios conectados
h: Intensidad del campo magnético externo
dt: Variación del tiempo a lo largo de un paso de Trotter
initial_state_angle: Una excitación inicial, $R_y(\theta)$ , que se aplicará de manera uniforme a todos los qubits

from typing import Any

from qiskit import QuantumCircuit

# Ising model parameters
num_steps = 10
J = -1.0
dt = 0.25 / abs(J)
h = 2.0 * abs(J)
initial_state_angle = np.pi / 18.0
rx_angle = 2.0 * h * dt
rzz_angle = 2.0 * J * dt


def generate_ising_circuit(
    num_qubits: int,
    num_steps: int,
    rx_angle: float,
    rzz_angle: float,
    coloring: dict[Any, list[tuple[int, int]]],
    layer_noise_models: list[PauliLindbladError] | None = None,
    initial_state_angle: float | None = None,
) -> QuantumCircuit:
    """Generate a quantum circuit implementing a transverse-field Ising model"""
    qc = QuantumCircuit(num_qubits)
    if initial_state_angle:
        qc.ry(initial_state_angle, range(num_qubits))
    qc.rx(rx_angle / 2, range(num_qubits))
    for i in range(num_steps):
        for j, layer in enumerate(coloring):
            edges = coloring[layer]
            if layer_noise_models:
                qc.append(layer_noise_models[j], qargs=range(num_qubits))
            for edge in edges:
                qc.rzz(rzz_angle, *edge)
        if i == num_steps - 1:
            qc.rx(rx_angle / 2, range(num_qubits))
        else:
            qc.rx(rx_angle, range(num_qubits))
    return qc


# Create the noiseless and noisy circuits
noiseless_circs = []
noisy_circs = []
for steps in range(1, num_steps + 1):
    noiseless_circs.append(
        generate_ising_circuit(
            num_qubits,
            steps,
            rx_angle,
            rzz_angle,
            color_to_edge,
            initial_state_angle=initial_state_angle,
        )
    )
    noisy_circs_per_step = []
    for noise_models in noise_models_per_EPLG:
        noisy_circs_per_step.append(
            generate_ising_circuit(
                num_qubits,
                steps,
                rx_angle,
                rzz_angle,
                color_to_edge,
                layer_noise_models=noise_models,
                initial_state_angle=initial_state_angle,
            )
        )
    noisy_circs.append(noisy_circs_per_step)
print(
    f"{num_steps} noiseless and {num_steps * len(target_EPLGs)} noisy Trotter circuits generated. {num_steps} different depths across {len(target_EPLGs)} different noise models"
)
print("\nBelow: Initial state and one noisy Trotter step.")
noisy_circs[0][0].draw("mpl", fold=-1)

Output:

10 noiseless and 50 noisy Trotter circuits generated. 10 different depths across 5 different noise models

Below: Initial state and one noisy Trotter step.

Especificar la variable observable y ejecutar simulaciones

Para esta demostración, simulamos los valores esperados del correlador medio de dos sitios:

$\langle O \rangle = \langle Z_{tot}^2(s) \rangle = \frac{1}{N^2}\sum \langle \Psi(\theta)|(\mathscr{U}^{\dagger})^sZ_jZ_k(\mathscr{U})^s|\Psi(\theta) \rangle$

donde $\Psi(\theta)$ corresponde a una rotación uniforme $R_y(\theta)$ de todos los qubits, $\mathscr{U}^s$ describe $s$ capas de Trotter, y $(j,k)$ indexa todos los pares de vértices conectados en la red.

Por último, utilizamos pauli_prop para simular los valores esperados observables para cada uno de los circuitos. Para esta demostración de nueve qubits, realizamos todas las simulaciones de forma exacta. No se llevará a cabo ningún truncamiento de la propagación de Pauli; por lo tanto, las diferencias en los valores esperados entre los distintos modelos de ruido pueden atribuirse íntegramente al error de la puerta. El proceso de simulación se lleva a cabo en cuatro pasos:

Mueve las puertas de Clifford del circuito hacia la parte delantera del mismo utilizando pauli_prop.evolve_through_cliffords
Propaga la observable a través de la parte no-Clifford del circuito utilizando pauli_prop.propagate_through_circuit
- Realizamos simulaciones exactas permitiendo que el observable alcance el tamaño del espacio completo de Pauli, $4^9$
Propaga el observable evolucionado a través de la parte de Clifford del circuito utilizando Qiskit's SparsePauliOp.evolve
Calcula el valor esperado con respecto al estado cero, $|0\rangle^{\otimes N}$ , sumando los coeficientes de cada término diagonal de $O$ (términos que contienen $Z$ o $I$ en todos los qubits)

import time

from pauli_prop import evolve_through_cliffords, propagate_through_circuit
from qiskit.quantum_info import Pauli

# Average ZZ-correlator observable
id_pauli = Pauli("I" * num_qubits)
observable = 2 * SparsePauliOp(
    [
        id_pauli.dot(Pauli("ZZ"), [i, j])
        for i in range(num_qubits)
        for j in range(i + 1, num_qubits)
    ]
)
observable /= num_qubits**2

# Pauli propagation parameters
max_terms = 4**num_qubits  # Exact propagation
atol = 1e-12

# Run simulations
exact_evs = []
noisy_evs = [[] for _ in range(len(target_EPLGs))]
st = time.perf_counter()
for i, noiseless_circ in enumerate(noiseless_circs):
    cliff, non_cliff = evolve_through_cliffords(noiseless_circ)
    evolved_obs = propagate_through_circuit(
        observable, non_cliff, max_terms=max_terms, atol=atol, frame="h"
    )[0]
    evolved_obs.paulis = evolved_obs.paulis.evolve(cliff, frame="h")
    exact_evs.append(
        float(evolved_obs.coeffs[~evolved_obs.paulis.x.any(axis=1)].sum())
    )
    for j in range(len(target_EPLGs)):
        noisy_circ = noisy_circs[i][j]
        cliff, non_cliff = evolve_through_cliffords(noisy_circ)
        evolved_obs = propagate_through_circuit(
            observable, non_cliff, max_terms=max_terms, atol=1e-12, frame="h"
        )[0]
        evolved_obs.paulis = evolved_obs.paulis.evolve(cliff, frame="h")
        noisy_evs[j].append(
            float(evolved_obs.coeffs[~evolved_obs.paulis.x.any(axis=1)].sum())
        )
print(
    f"Ran {len(noiseless_circs)} noiseless and {len(target_EPLGs) * num_steps} noisy simulations in {int(time.perf_counter() - st)}s."
)

Output:

Ran 10 noiseless and 50 noisy simulations in 103s.

Observa el efecto del error de puerta en el modelo

Recuerda que, dado que se trata de un experimento con nueve qubits, la rutina de propagación de Pauli es exacta, y todo el error que se observa en los gráficos de ruido puede atribuirse al error de las puertas.

import matplotlib.pyplot as plt

xs = range(1, num_steps + 1)
plt.plot(xs, exact_evs, label="Noiseless", color="black", marker="o")
colors = [".3", ".4", ".5", ".6", ".7"]
for i, evs in enumerate(noisy_evs):
    plt.plot(
        xs,
        evs,
        label=f"{target_EPLGs[i]} EPLG",
        linestyle="--",
        color=colors[i],
        marker="o",
    )
plt.xlabel("# Trotter steps")
plt.ylabel(r"$\langle Z_{tot}^2 \rangle$")
plt.legend()
plt.show()

Output:

¿Le ha resultado útil esta página?

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