Transición de fase de Nishimori

Estimación de tiempo de ejecución: 3 minutos en un procesador Heron r2 (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 obtener los siguientes resultados:

Comprender la transición de fase de Nishimori y cómo se manifiesta en forma de entrelazamiento de largo alcance en el modelo de Ising con enlaces aleatorios.
Implementar el protocolo de generación de entrelazamiento mediante medición (GEM) en hardware cuántico utilizando mediciones en medio del circuito y circuitos de profundidad constante.
Caracteriza la transición extrayendo la correlación de dos puntos y la varianza normalizada de la magnetización a partir de los datos experimentales.

Requisitos previos

Recomendamos que te familiarices con los siguientes temas antes de seguir este tutorial:

La guía sobre los qubits de medición, en concreto la sección dedicada a la medición a mitad de circuito en la que se basa el protocolo GEM.
Simulación exacta y con ruido mediante primitivas de Qiskit Aer, que es cómo se ejecuta la sección a pequeña escala.
Entrelazamiento de largo alcance con circuitos dinámicos, un tutorial complementario que utiliza el mismo paradigma de entrelazamiento basado en mediciones.
Red hexagonal densa, la topología de hardware « IBM® » sobre la que se construye la red de plaquetas.

En segundo plano

Este tutorial muestra cómo llevar a cabo una transición de fase de Nishimori en un procesador cuántico. Este experimento se describió originalmente en el artículo «Realizing the Nishimori transition across the error threshold for constant-depth quantum circuits ».

La transición de fase de Nishimori se refiere a la transición entre las fases ordenadas de corto y largo alcance en el modelo de Ising de enlaces aleatorios. En un ordenador cuántico, la fase ordenada de largo alcance se manifiesta como un estado en el que los qubits están entrelazados en todo el dispositivo. Este estado altamente entrelazado se prepara mediante el protocolo de generación de entrelazamiento por medición (GEM). Mediante el uso de mediciones a mitad del circuito, el protocolo GEM es capaz de entrelazar qubits en todo el dispositivo utilizando circuitos de profundidad constante. En este tutorial se utiliza la implementación del protocolo GEM del paquete de software GEM Suite.

Requisitos

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

Qiskit SDK v1.0 o posterior, con soporte de visualización
Qiskit Runtime v0.22 o posterior (pip install qiskit-ibm-runtime)
Qiskit Aer v0.14 o posterior (pip install qiskit-aer)
GEM Suite (pip install gem-suite)

Configuración

import matplotlib.pyplot as plt
import warnings

from collections import defaultdict

from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_aer import AerSimulator

from qiskit.transpiler import generate_preset_pass_manager

from gem_suite import PlaquetteLattice
from gem_suite.experiments import GemExperiment

Ejemplo de simulador a pequeña escala

AerSimulatorEn esta sección se explica paso a paso todo el proceso en el entorno sin ruido. La red de plaquetas se limita a una sola plaqueta (12 qubits), de modo que la simulación sigue siendo pequeña y rápida, al tiempo que se ponen a prueba todos los componentes del protocolo GEM: la medición a mitad del circuito, el barrido del ángulo « $R_{ZZ}$ », la decodificación y el análisis de la varianza normalizada. Posteriormente, ese mismo flujo de trabajo se amplía a varias plaquetas y a toda la red en hardware real.

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

El protocolo GEM funciona en un procesador cuántico cuya conectividad entre qubits viene descrita por una red. Los procesadores « IBM Quantum® » actuales utilizan la red de hexágonos densos. Los qubits del procesador se agrupan en plaquetas en función de la celda unitaria de la red que ocupan. Dado que un qubit puede aparecer en más de una celda unitaria, las plaquetas no son disjuntas. En la red hexagonal densa, una plaqueta contiene 12 qubits. Las propias plaquetas también forman redes, en las que dos plaquetas están conectadas si comparten algún qubit. En la red hexagonal densa, las plaquetas vecinas comparten tres qubits.

En el paquete de software GEM Suite, la clase fundamental para implementar el protocolo GEM es PlaquetteLattice, que representa el retículo de plaquetas (que es distinto del retículo «heavy-hex»). A PlaquetteLattice se puede inicializar a partir de un mapa de acoplamiento de qubits. Actualmente, solo se admiten mapas de acoplamiento «heavy-hex».

La siguiente celda de código inicializa una red de plaquetas a partir del mapa de acoplamiento de una unidad de procesamiento cuántico (QPU). La estructura de placas no siempre abarca todo el hardware. Por ejemplo, ibm_torino cuenta con un total de 133 qubits, pero la red de plaquetas más grande que cabe en el dispositivo solo utiliza 125 de ellos, lo que equivale a 18 plaquetas; ibm_pittsburgh (156 qubits) también alberga 144 qubits en 21 plaquetas. Lo mismo ocurre con otras QPU de alta densidad con distintos números de qubits.

# QiskitRuntimeService.save_account(channel="ibm_quantum", token="<YOUR_API_KEY>", overwrite=True,
# set_as_default=True)
service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=127
)
aer_backend = AerSimulator.from_backend(backend)
plaquette_lattice = PlaquetteLattice.from_coupling_map(backend.coupling_map)

print(f"Number of qubits in backend: {backend.num_qubits}")
print(
    f"Number of qubits in plaquette lattice: {len(list(plaquette_lattice.qubits()))}"
)
print(f"Number of plaquettes: {len(list(plaquette_lattice.plaquettes()))}")

Puedes visualizar el entramado de plaquetas generando un diagrama de su representación gráfica. En el diagrama, las placas están representadas por hexágonos etiquetados, y dos placas están conectadas por un borde si comparten qubits.

plaquette_lattice.draw_plaquettes()

Output:

Puedes recuperar información sobre placas individuales, como los qubits que contienen, utilizando el método plaquettes .

# Get a list of the plaquettes
plaquettes = list(plaquette_lattice.plaquettes())
# Display information about plaquette 0
plaquettes[0]

Output:

PyPlaquette(index=0, qubits=[3, 4, 5, 6, 7, 16, 17, 23, 24, 25, 26, 27], neighbors=[4, 3, 1])

También puede producir un diagrama de los qubits subyacentes que forman la red de plaquetas.

plaquette_lattice.draw_qubits()

Output:

Además de las etiquetas de los qubits y los bordes que indican qué qubits están conectados, el diagrama contiene tres datos adicionales que son relevantes para el protocolo GEM:

Cada qubit está sombreado (gris) o sin sombrear. Los qubits sombreados son qubits de "sitio" que representan los sitios del modelo Ising, y los qubits no sombreados son qubits de "enlace" utilizados para mediar en las interacciones entre los qubits de sitio.
Cada qubit de sitio está etiquetado como (A) o (B), indicando uno de los dos papeles que un qubit de sitio puede desempeñar en el protocolo GEM (los papeles se explican más adelante).
Cada arista se colorea con uno de los seis colores, lo que permite dividir las aristas en seis grupos. Esta división determina cómo se pueden paralelizar las puertas de dos qubits, así como los distintos patrones de programación que probablemente generen diferentes niveles de error en un procesador cuántico con ruido. Dado que los bordes de un grupo son disjuntos, se puede aplicar simultáneamente una capa de puertas de dos qubits en dichos bordes. De hecho, es posible dividir los seis colores en tres grupos de dos colores, de tal manera que la unión de cada grupo de dos colores siga siendo disjunta. Por lo tanto, solo se necesitan tres capas de puertas de dos qubits para activar cada borde. Hay 12 formas de dividir los seis colores de esta manera, y cada una de ellas da lugar a una programación de puertas de tres capas diferente.

Ahora que has creado una red de plaquetas, el siguiente paso es inicializar un GemExperiment objeto, pasando tanto la red de plaquetas como el backend en el que pretendes ejecutar el experimento. La GemExperiment clase se encarga de la implementación efectiva del protocolo GEM, lo que incluye la generación de circuitos, el envío de trabajos y el análisis de los datos. La siguiente celda de código inicializa la clase de experimento, al tiempo que limita la red de plaquetas a una sola plaqueta (12 qubits), lo que permite que la simulación sea breve y rápida. La red completa de plaquetas se utiliza posteriormente al pasar a hardware real.

# Filter the plaquette lattice down to a single plaquette (12 qubits)
# so the AerSimulator run stays fast. The full lattice is used later
# in the large-scale hardware example.
gem_exp = GemExperiment(plaquette_lattice.filter([9]), backend=aer_backend)

# visualize the plaquette lattice after filtering
plaquette_lattice.filter([9]).draw_qubits()

Output:

Un circuito de protocolo GEM se construye siguiendo los siguientes pasos:

Prepara el estado $|+\rangle$ aplicando una puerta Hadamard a cada qubit.
Aplica una puerta « $R_{ZZ}$ » entre cada par de qubits conectados. Para ello, puedes utilizar tres capas de compuertas. Cada puerta « $R_{ZZ}$ » actúa sobre un qubit de sitio y un qubit de enlace. Si el qubit de sitio está etiquetado como (B), el ángulo se fija en $\frac{\pi}{2}$ . Si el qubit de sitio está etiquetado como (A), el ángulo puede variar, lo que da lugar a circuitos diferentes. Por defecto, el rango de ángulos está establecido en 21 puntos equidistantes entre $0$ y $\frac{\pi}{2}$ , ambos incluidos.
Mide cada qubit de enlace en la base de Pauli $X$ . Dado que los qubits se miden en la base de Pauli $Z$ , puedes hacerlo aplicando una puerta de Hadamard antes de medir el qubit.

Tenga en cuenta que el documento citado en la introducción de este tutorial utiliza una convención diferente para el ángulo $R_{ZZ}$ , que difiere de la convención utilizada en este tutorial por un factor de 2.

En el tercer paso, solo se miden los qubits de enlace. Para comprender en qué estado permanecen los qubits de sitio, resulta ilustrativo considerar el caso en el que el ángulo « $R_{ZZ}$ » aplicado a los qubits de sitio (A) en el paso dos es igual a « $\frac{\pi}{2}$ ». En este caso, los qubits de sitio quedan en un estado altamente entrelazado similar al estado GHZ,

\lvert \text{GHZ} \rangle = \lvert 00 \cdots 00 \rangle + \lvert 11 \cdots 11 \rangle.

Debido al carácter aleatorio de los resultados de las mediciones, el estado real de los qubits del sistema podría ser un estado diferente con orden de largo alcance, por ejemplo, $\lvert 00110 \rangle + \lvert 11001 \rangle$ . Sin embargo, el estado GHZ puede recuperarse aplicando una operación de decodificación basada en los resultados de las mediciones. Cuando el ángulo « $R_{ZZ}$ » se reduce desde $\frac{\pi}{2}$ , el orden de largo alcance aún puede recuperarse hasta un ángulo crítico, que, en ausencia de ruido, es aproximadamente $0.3 \pi$ . Por debajo de este ángulo, el estado resultante ya no presenta entrelazamiento de largo alcance. Esta transición entre la presencia y la ausencia de orden a larga distancia es la transición de fase de Nishimori.

En la descripción anterior, los qubits del sitio no se midieron, y la operación de decodificación puede realizarse aplicando puertas cuánticas. En el experimento tal y como se ha implementado en el paquete GEM, los qubits de sitio se miden efectivamente, y la operación de decodificación se aplica en una etapa de posprocesamiento clásico.

En la descripción anterior, la operación de decodificación puede llevarse a cabo aplicando puertas cuánticas a los qubits del sitio para recuperar el estado cuántico. Sin embargo, si el objetivo es medir el estado de forma inmediata (por ejemplo, con fines de caracterización), se pueden medir los qubits de sitio junto con los qubits de enlace y aplicar la operación de decodificación en una etapa de posprocesamiento clásico.

Además de depender del ángulo « $R_{ZZ}$ » del paso dos, que por defecto recorre 21 valores, el circuito del protocolo GEM también depende del patrón de programación utilizado para implementar las tres capas de puertas « $R_{ZZ}$ ». Como ya se ha comentado anteriormente, existen 12 patrones de programación de este tipo. Por lo tanto, el número total de circuitos del experimento es de $21 \times 12 = 252$ .

Los circuitos del experimento se pueden generar utilizando el circuits método de la GemExperiment clase.

circuits = gem_exp.circuits()
print(f"Total number of circuits: {len(circuits)}")

Output:

Total number of circuits: 252

A efectos de este tutorial, basta con considerar un único patrón de programación. La siguiente celda de código restringe el experimento al primer patrón de programación. Como resultado, el experimento sólo tiene 21 circuitos, uno por cada ángulo de barrido $R_{ZZ}$ .

# Restrict experiment to the first scheduling pattern
gem_exp.set_experiment_options(schedule_idx=0)

# There are less circuits now
circuits = gem_exp.circuits()
print(f"Total number of circuits: {len(circuits)}")

# Print the RZZ angles swept over
print(f"RZZ angles:\n{gem_exp.parameters()}")

Output:

Total number of circuits: 21
RZZ angles:
[0.         0.07853982 0.15707963 0.23561945 0.31415927 0.39269908
 0.4712389  0.54977871 0.62831853 0.70685835 0.78539816 0.86393798
 0.9424778  1.02101761 1.09955743 1.17809725 1.25663706 1.33517688
 1.41371669 1.49225651 1.57079633]

La siguiente celda de código dibuja un diagrama del circuito en el índice 5. Para reducir el tamaño del diagrama, se eliminan las compuertas de medida al final del circuito.

# Get the circuit at index 5
circuit = circuits[5]
# Remove the final measurements to ease visualization
circuit.remove_final_measurements()
# Draw the circuit
circuit.draw("mpl", fold=-1, scale=0.5)

Output:

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

La compilación de circuitos cuánticos para su ejecución en hardware suele constar de varias etapas. Por lo general, las etapas que suponen una mayor carga computacional son la elección de la disposición de los qubits, el enrutamiento de las puertas de dos qubits para adaptarlas a la conectividad de los qubits del hardware y la optimización del circuito para minimizar el número de puertas y su profundidad. En el protocolo GEM, las fases de diseño de la disposición y del enrutamiento son innecesarias, ya que la conectividad del hardware ya está incorporada en el diseño del protocolo. Los circuitos ya cuentan con una disposición de qubits, y las puertas de dos qubits ya están asignadas a conexiones nativas. Además, con el fin de preservar la estructura del circuito a medida que varía el ángulo e $R_{ZZ}$ , solo se debe llevar a cabo una optimización muy básica del circuito.

La clase GemExperiment transpila de forma transparente los circuitos al ejecutar el experimento. Las etapas de diseño y enrutamiento ya están anuladas por defecto para no hacer nada, y la optimización del circuito se realiza a un nivel que sólo optimiza las puertas de un solo qubit. Sin embargo, puede anular o pasar opciones adicionales utilizando el método set_transpile_options . A efectos de visualización, la siguiente celda de código transpila manualmente el circuito mostrado anteriormente, y dibuja el circuito transpilado.

# Demonstrate setting transpile options
gem_exp.set_transpile_options(
    optimization_level=1  # This is the default optimization level
)
pass_manager = generate_preset_pass_manager(
    backend=aer_backend,
    initial_layout=list(gem_exp.physical_qubits),
    **dict(gem_exp.transpile_options),
)
transpiled = pass_manager.run(circuit)
transpiled.draw("mpl", idle_wires=False, fold=-1, scale=0.5)

Output:

Paso 3: Ejecutar utilizando Qiskit primitives

Para ejecutar los circuitos del protocolo GEM en el hardware, llame al método run del objeto GemExperiment . Puede especificar el número de tomas que desea muestrear de cada circuito. El método run devuelve un objeto ExperimentData que debe guardar en una variable. Tenga en cuenta que el método run sólo envía trabajos sin esperar a que terminen, por lo que es una llamada no bloqueante.

exp_data = gem_exp.run(shots=10_000)

Para esperar los resultados, llame al método block_for_results del objeto ExperimentData . Esta llamada hará que el intérprete se cuelgue hasta que finalicen los trabajos.

# The noiseless AerSimulator produces zero-variance UFloat objects in the
# analysis, which triggers a harmless warning from the `uncertainties`
# library. Suppress it so the output stays clean.
with warnings.catch_warnings():
    warnings.filterwarnings(
        "ignore", message="Using UFloat objects with std_dev==0"
    )
    exp_data.block_for_results()
exp_data

Output:

ExperimentData(GemExperiment, 90bf2a90-f729-4c4e-a6da-664aecb11039, job_ids=['04a7c405-47fd-46ca-aa4b-aaf7e339cfbe'], metadata=<5 items>, figure_names=['two_point_correlation.svg', 'normalized_variance.svg', 'plaquette_ops.svg', 'bond_ops.svg'])

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

En un ángulo $R_{ZZ}$ de $\frac{\pi}{2}$ , el estado descodificado sería el estado GHZ en ausencia de ruido. El orden de largo alcance del estado GHZ puede visualizarse trazando la magnetización de las cadenas de bits medidas. La magnetización $M$ se define como la suma de los operadores Pauli $Z$ de un solo qubit,

M = \sum_{j=1}^N Z_j,

donde $N$ es el número de qubits del sitio. Su valor para una cadena de bits es igual a la diferencia entre el número de ceros y el número de unos. Al medir el estado GHZ se obtiene, con igual probabilidad, el estado de todos ceros o el de todos unos, por lo que la magnetización sería $+N$ la mitad del tiempo y $-N$ la otra mitad. Si hubiera errores debidos al ruido, también aparecerían otros valores, pero si el ruido no es demasiado intenso, la distribución seguiría alcanzando su máximo cerca de $+N$ y $-N$ .

Para las cadenas de bits en bruto antes de la descodificación, la distribución de la magnetización sería equivalente a la de cadenas de bits uniformemente aleatorias, en ausencia de ruido.

La siguiente celda de código traza la magnetización de las cadenas de bits sin procesar y las cadenas de bits descodificadas en el ángulo $R_{ZZ}$ de $\frac{\pi}{2}$ .

def magnetization_distribution(
    counts_dict: dict[str, int],
) -> dict[str, float]:
    """Compute magnetization distribution from counts dictionary."""
    # Construct dictionary from magnetization to count
    mag_dist = defaultdict(float)
    for bitstring, count in counts_dict.items():
        mag = bitstring.count("0") - bitstring.count("1")
        mag_dist[mag] += count
    # Normalize
    shots = sum(counts_dict.values())
    for mag in mag_dist:
        mag_dist[mag] /= shots
    return mag_dist


# Get counts dictionaries with and without decoding
data = exp_data.data()
# Get the last data point, which is at the angle for the GHZ state
raw_counts = data[-1]["counts"]
# Without decoding
site_indices = [
    i for i, q in enumerate(gem_exp.plaquettes.qubits()) if q.role == "Site"
]
site_raw_counts = defaultdict(int)
for key, val in raw_counts.items():
    site_str = "".join(key[-1 - i] for i in site_indices)
    site_raw_counts[site_str] += val
# With decoding
_, site_decoded_counts = gem_exp.plaquettes.decode_outcomes(
    raw_counts, return_counts=True
)

# Compute magnetization distribution
raw_magnetization = magnetization_distribution(site_raw_counts)
decoded_magnetization = magnetization_distribution(site_decoded_counts)

# Plot
plt.bar(*zip(*raw_magnetization.items()), label="raw")
plt.bar(*zip(*decoded_magnetization.items()), label="decoded", width=0.3)
plt.legend()
plt.xlabel("Magnetization")
plt.ylabel("Frequency")
plt.title("Magnetization distribution with and without decoding")

Output:

Text(0.5, 1.0, 'Magnetization distribution with and without decoding')

Para caracterizar de forma más rigurosa el orden de largo alcance, se puede examinar la correlación media de dos puntos $f$ , definida como

f = \frac{1}{N^2} \left(\langle M^2 \rangle - \langle M \rangle ^2\right).

Un valor más alto indica un mayor grado de enredo. La clase GemExperiment calcula automáticamente este valor para las cadenas de bits descodificadas como parte del procesamiento de los datos experimentales. Almacena una cifra accesible a través del método figure de la clase de datos del experimento. En este caso, el nombre de la figura es two_point_correlation.

exp_data.figure("two_point_correlation")

Output:

Para determinar el punto crítico de la transición de fase Nishimori, se puede observar la varianza normalizada de $M^2 / N$ , definida como

g = \frac{1}{N^3} \left(\langle M^4 \rangle - \langle M^2 \rangle^2\right),

que cuantifica la cantidad de fluctuación en la magnetización al cuadrado. Este valor se maximiza en el punto crítico de la transición de fase Nishimori. En ausencia de ruido, el punto crítico se produce aproximadamente en $0.3 \pi$ . En presencia de ruido, el punto crítico se desplaza más arriba, pero la transición de fase se sigue observando siempre que el punto crítico se produzca por debajo de $0.5 \pi$ .

exp_data.figure("normalized_variance")

Output:

Ejemplo de hardware a gran escala

Una vez validado el protocolo en un simulador, ya puedes ampliar la escala del experimento y ejecutarlo en el hardware cuántico real seleccionado en la sección «Configuración ». En este ejemplo se utilizan dos problemas de mayor tamaño:

Seis plaquetas (aprox. 49 qubits) : una serie de tamaño medio que ya muestra el desplazamiento hacia la derecha del punto crítico bajo el efecto del ruido del hardware.
La red completa de plaquetas : todas las plaquetas que admite la topología «heavy-hex» del dispositivo (por ejemplo, 18 plaquetas / 125 qubits en ibm_torino o 21 plaquetas / 144 qubits en ibm_pittsburgh), entrelazando qubits en todo el dispositivo mediante circuitos de profundidad constante.

La celda de código que aparece a continuación es autónoma: construye la red de plaquetas a partir del mapa de acoplamiento del backend y ejecuta ambos experimentos, por lo que esta sección se puede ejecutar después de las celdas de configuración sin necesidad de ejecutar primero la sección a pequeña escala.

# -------------------------Step 1-------------------------
# Initialize the runtime service, pick a real quantum hardware backend,
# and build the plaquette lattice from its coupling map. This is repeated
# from the small-scale example so this cell can run standalone after the
# Setup section. The full plaquette lattice is the "large-scale" target;
# a six-plaquette subset (range(3, 9)) is also used to show an intermediate
# scaling step.
service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=127
)
plaquette_lattice = PlaquetteLattice.from_coupling_map(backend.coupling_map)

# Build a GemExperiment for the full plaquette lattice and one for the
# six-plaquette subset, each restricted to a single scheduling pattern so
# the experiment has one circuit per RZZ angle (21 circuits total).
gem_exp_full = GemExperiment(plaquette_lattice, backend=backend)
gem_exp_full.set_experiment_options(schedule_idx=0)
gem_exp_6 = GemExperiment(
    plaquette_lattice.filter(range(3, 9)), backend=backend
)
gem_exp_6.set_experiment_options(schedule_idx=0)

circuits = gem_exp_full.circuits()
print(f"Total number of circuits (full lattice): {len(circuits)}")

# -------------------------Step 2-------------------------
# GemExperiment transpiles internally for the target backend: the layout
# and routing stages are overridden because the plaquette lattice already
# matches the hardware connectivity, and optimization is restricted so the
# RZZ angle structure is preserved. The code below manually transpiles one
# circuit from the six-plaquette experiment with the same settings this
# experiment will use, and draws it for inspection. (The full-lattice
# transpiled circuit has too many qubits to visualize cleanly, so the
# six-plaquette circuit is used here as a representative example.)
gem_exp_6.set_transpile_options(optimization_level=1)
circuits_6 = gem_exp_6.circuits()
pass_manager = generate_preset_pass_manager(
    backend=backend,
    initial_layout=list(gem_exp_6.physical_qubits),
    **dict(gem_exp_6.transpile_options),
)
transpiled = pass_manager.run(circuits_6[5])
display(transpiled.draw("mpl", idle_wires=False, fold=-1, scale=0.5))

# -------------------------Step 3-------------------------
# Run both problem sizes on real hardware:
#   1. Six plaquettes (~49 qubits) — an intermediate scale-up.
#   2. The full plaquette lattice — every plaquette the device supports.
exp_data_6 = gem_exp_6.run(shots=10_000, job_tags=["TUT_NPT"])
exp_data_full = gem_exp_full.run(shots=10_000, job_tags=["TUT_NPT"])
exp_data_6.block_for_results()
exp_data_full.block_for_results()

# -------------------------Step 4-------------------------
# Plot the normalized variance at each scale. The peak marks the critical
# point of the Nishimori transition; as the system grows, hardware noise
# shifts the peak rightward.
display(exp_data_6.figure("normalized_variance"))
exp_data_full.figure("normalized_variance")

Output:

Total number of circuits (full lattice): 21

Ten en cuenta que, dependiendo del nivel de ruido del backend utilizado, es posible que las curvas de varianza normalizada en los tamaños más grandes no muestren un pico claro dentro del rango de ángulos barridos. En las simulaciones anteriores, el pico se ha desplazado hasta $0.5 \pi$ , el extremo derecho del rango de variación (según indican los informes critical_angle = 0.5000 de análisis tanto de las simulaciones con seis plaquetas como de las realizadas en la red completa). Esto significa que el ruido del hardware ha desplazado el punto crítico hasta (o justo más allá de) el límite del rango de ángulos físicamente significativo del protocolo, por lo que la transición se encuentra en el límite de lo que este barrido puede resolver.

Conclusión

En este tutorial, has llevado a cabo una transición de fase de Nishimori en un procesador cuántico utilizando el protocolo GEM. Los parámetros que has analizado durante el posprocesamiento —en concreto, la correlación de dos puntos y la varianza normalizada— sirven como indicadores de la capacidad del dispositivo para generar estados entrelazados de largo alcance. Estas pruebas comparativas amplían la utilidad del protocolo GEM más allá del estudio de fenómenos físicos interesantes. Como parte del protocolo, se entrelazaron qubits en todo el dispositivo utilizando circuitos de profundidad constante únicamente. Esta hazaña solo es posible gracias al uso que hace el protocolo de mediciones a mitad de circuito. En este experimento, el estado entrelazado se midió de inmediato, pero se podría considerar la posibilidad de seguir investigando utilizando este estado en otros procesos cuánticos.

Próximos pasos

Recomendaciones

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

Referencias

[1] E. H. Chen, « G.-Y ». Zhu, R. Verresen, A. Seif, E. Bäumer, D. Layden, N. Tantivasadakarn, G. Zhu, S. Sheldon, A. Vishwanath, S. Trebst, A. Kandala. Realización de la transición de Nishimori por encima del umbral de error para circuitos cuánticos de profundidad constante. arXiv:2309.02863 (2023).

[2.] Paquete de software GEM Suite.

¿Le ha resultado útil esta página?

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