Nota

Esta página fue generada a partir de docs/tutorials/chsh_with_estimator.ipynb.

Demostrar el incumplimiento de la desigualdad CHSH con la primitiva Estimator

En este tutorial, ejecutarás un experimento en una computadora cuántica para demostrar el incumplimiento de la desigualdad CHSH con la primitiva Estimator.

The violation of the CHSH inequality is used to show that quantum mechanics is incompatible with local hidden-variable theories. This is an important experiment for understanding the foundation of quantum mechanics. The 2022 Nobel Prize for Physics was awarded to Alain Aspect, John Clauser and Anton Zeilinger in part for their pioneering work in quantum information science, and in particular, their experiments with entangled photons demonstrating violation of Bell’s inequalities. An experimental method by which one can test Bell’s inequality was put forth by Clauser, Horne, Shimony, and Holt (CHSH) in 1969, and forms the basis for the experiment conducted here. It’s truly incredible that you can use Qiskit and an IBM Quantum system to conduct this experiment from the comfort of your home!

Información de antecedentes

Desigualdad CHSH

La desigualdad CHSH, llamada así por los autores Clauser, Horne, Shimony y Holt, se usa para demostrar experimentalmente el teorema de Bell. Este teorema afirma que las teorías de variables ocultas locales no se pueden dar cuenta de algunas consecuencias del entrelazamiento en la mecánica cuántica.

Para este experimento, crearemos un par entrelazado en el que mediremos cada qubit en dos bases diferentes. Etiquetaremos las bases para el primer qubit \(A\) y \(a\) y las bases para el segundo qubit \(B\) y \(b\). Esto nos permite calcular la cantidad \(S_1\) de CHSH:

\[S_1 = A(B-b) + a(B+b).\]

Cada observable es \(+1\) o \(-1\). Claramente, uno de los términos \(B\pm b\) debe ser \(0\), y el otro debe ser \(\pm 2\). Por lo tanto, \(S_1 = \pm 2\). El valor promedio de \(S_1\) debe satisfacer la desigualdad:

\[|\langle S_1 \rangle|\leq 2.\]

Expandir \(S_1\) en términos de \(A\), \(a\), \(B\), y \(b\) da como resultado:

\[|\langle S_1 \rangle| = |\langle AB \rangle - \langle Ab \rangle + \langle aB \rangle + \langle ab \rangle| \leq 2\]

Puedes definir otra cantidad \(S_2\) de CHSH:

\[S_2 = A(B+b) - a(B-b),\]

Esto conduce a otra desigualdad:

\[|\langle S_2 \rangle| = |\langle AB \rangle + \langle Ab \rangle - \langle aB \rangle + \langle ab \rangle| \leq 2\]

Si la mecánica cuántica puede describirse mediante teorías de variables ocultas locales, las desigualdades anteriores deben ser ciertas. Sin embargo, como vas a demostrar en este cuaderno, estas desigualdades pueden incumplirse en una computadora cuántica. Por lo tanto, la mecánica cuántica no es compatible con las teorías de variables ocultas locales.

Si deseas obtener más información, puedes leer el capítulo sobre la desigualdad CHSH en el libro de texto de Qiskit.

Descripción General

Crearás un par entrelazado entre dos qubits en una computadora cuántica creando el estado de Bell \(|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}\). Con la primitiva Estimator, puedes obtener directamente los valores esperados necesarios (\(\langle AB \rangle, \langle Ab \rangle, \langle aB \rangle\), and \(\langle ab \rangle\)) para calcular los valores esperados de las dos cantidades \(\langle S_1\rangle\) y \(\langle S_2\rangle\) de CHSH. Antes de la introducción de la primitiva Estimator, deberías construir los valores esperados a partir de los resultados de la medición.

Medirás el segundo qubit en las bases \(Z\) y \(X\). El primer qubit se medirá también en bases ortogonales, pero con un ángulo con respecto al segundo qubit, que vamos a barrer entre \(0\) y \(2\pi\). Como verás, la primitiva Estimator hace que ejecutar circuitos parametrizados sea muy fácil. En lugar de crear una serie de circuitos CHSH, solo necesitas crear un circuito CHSH con un parámetro que especifique el ángulo de medición y una serie de valores de fase para el parámetro.

Finalmente, analizarás los resultados y los graficarás contra el ángulo de medición. Verás que para cierto rango de ángulos de medición, los valores esperados de las cantidades CHSH serán \(|\langle S_1\rangle| > 2\) o \(|\langle S_2\rangle| > 2\), lo que demuestra el incumplimiento de la desigualdad CHSH.

Nota

Para los usuarios expertos, debemos mencionar que hay varias lagunas que deben cerrarse cuando se incumple la desigualdad para afirmar que la localidad o el realismo han sido refutados. Ve el último párrafo (justo antes de la sección «Exercise») en el capítulo CHSH en el libro de texto de Qiskit para discusiones.

Configuración

# General
import numpy as np

# Qiskit imports
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.quantum_info import SparsePauliOp

# Runtime imports
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator

# Plotting routines
import matplotlib.pyplot as plt
import matplotlib.ticker as tck

Conéctate al servicio Qiskit Runtime

Before running circuits, you need to connect to the Qiskit Runtime service instance, and select a target backend:

service = QiskitRuntimeService()
backend = service.get_backend("ibm_sherbrooke")

Paso 1: Crear circuitos CHSH

Crea un circuito CHSH parametrizado

Primero, escribimos el circuito con el parámetro \(\theta\), al que llamamos theta. La primitiva Estimator puede simplificar enormemente la construcción de circuitos y el análisis de las salidas al proporcionar directamente los valores esperados de los observables. Muchos problemas de interés, especialmente para aplicaciones a corto plazo en sistemas ruidosos, se pueden formular en términos de valores esperados. Para una máxima generalización, la primitiva Estimator requiere circuitos sin mediciones.

theta = Parameter("$\\theta$")

chsh_circuit_no_meas = QuantumCircuit(2)
chsh_circuit_no_meas.h(0)
chsh_circuit_no_meas.cx(0, 1)
chsh_circuit_no_meas.ry(theta, 0)
chsh_circuit_no_meas.draw("mpl")

Crea una lista de valores de fase para asignarlos más adelante

Después de crear el circuito CHSH parametrizado, crearás una lista de valores de fase que se asignarán al circuito en el siguiente paso. Puedes usar el siguiente código para crear una lista de 21 valores de fase que van desde \(0\) a \(2 \pi\) con espacios iguales, es decir, \(0\), \(0.1 \pi\), \(0.2 \pi\), …, \(1.9 \pi\), \(2 \pi\).

number_of_phases = 21
phases = np.linspace(0, 2 * np.pi, number_of_phases)
# Phases need to be expressed as list of lists in order to work
individual_phases = [[ph] for ph in phases]

Observables

Ahora necesitamos observables a partir de los cuales calcular los valores esperados. En nuestro caso, buscamos bases ortogonales para cada qubit, dejando que la rotación parametrizada \(Y\) para el primer qubit, barra la base de medición casi continuamente con respecto a la segunda base del qubit. Por lo tanto, elegiremos los observables \(ZZ\), \(ZX\), \(XZ\), y \(XX\).

ZZ = SparsePauliOp.from_list([("ZZ", 1)])
ZX = SparsePauliOp.from_list([("ZX", 1)])
XZ = SparsePauliOp.from_list([("XZ", 1)])
XX = SparsePauliOp.from_list([("XX", 1)])

ops = [ZZ, ZX, XZ, XX]
num_ops = len(ops)

Paso 2: Enviar los circuitos a una computadora cuántica en la nube

In order to execute the entire experiment in one call to the Estimator we need to batch the circuit and operators together, repeating each for the requested number_of_phases points.

batch_circuits = [chsh_circuit_no_meas] * number_of_phases * num_ops
batch_ops = [op for op in ops for _ in individual_phases]

We can now create an Estimator instance using our selected backend, and execute our batched circuits and observables:

estimator = Estimator(backend)

batch_expvals = (
    estimator.run(
        batch_circuits, batch_ops, parameter_values=individual_phases * num_ops, shots=int(1e4)
    )
    .result()
    .values
)

The individual expectation values can then be extracted from the batched results:

ZZ_expval, ZX_expval, XZ_expval, XX_expval = [
    batch_expvals[kk * number_of_phases : (kk + 1) * number_of_phases] for kk in range(num_ops)
]

Paso 3: Analizar los resultados

Después de ejecutar los circuitos, necesitamos construir las funciones testigo de CHSH. Primero construimos las cantidades \(\langle AB \rangle\), \(\langle Ab \rangle\), \(\langle aB \rangle\), y \(\langle ab \rangle\), observando la paridad de los resultados de las cuatro familias de circuitos que construimos (dos bases de medición para cada uno de los dos qubits). Luego usamos esas cantidades para construir las funciones testigo como se definió anteriormente.

# <CHSH1> = <AB> - <Ab> + <aB> + <ab>
chsh1_est = ZZ_expval - ZX_expval + XZ_expval + XX_expval

# <CHSH2> = <AB> + <Ab> - <aB> + <ab>
chsh2_est = ZZ_expval + ZX_expval - XZ_expval + XX_expval

¡Ten en cuenta que ahora no tenemos que construir los observables nosotros mismos porque nos los devuelven! Los valores esperados calculados se dan en result.values. Lo que se regresa es una carga muy pequeña de datos.

fig, ax = plt.subplots(figsize=(10, 6))
# results from hardware
ax.plot(phases / np.pi, chsh1_est, "o-", label="CHSH1", zorder=3)
ax.plot(phases / np.pi, chsh2_est, "o-", label="CHSH2", zorder=3)
# classical bound +-2
ax.axhline(y=2, color="0.9", linestyle="--")
ax.axhline(y=-2, color="0.9", linestyle="--")
# quantum bound, +-2√2
ax.axhline(y=np.sqrt(2) * 2, color="0.9", linestyle="-.")
ax.axhline(y=-np.sqrt(2) * 2, color="0.9", linestyle="-.")
ax.fill_between(phases / np.pi, 2, 2 * np.sqrt(2), color="0.6", alpha=0.7)
ax.fill_between(phases / np.pi, -2, -2 * np.sqrt(2), color="0.6", alpha=0.7)
# set x tick labels to the unit of pi
ax.xaxis.set_major_formatter(tck.FormatStrFormatter("%g $\pi$"))
ax.xaxis.set_major_locator(tck.MultipleLocator(base=0.5))
# set title, labels, and legend
plt.title(f"Violation of CHSH Inequality ({backend.name})")
plt.xlabel("Theta")
plt.ylabel("CHSH witness")
plt.legend();

En la figura, las líneas discontinuas rojas delimitan los límites clásicos (\(\pm 2\)) y las líneas azules punteadas señalan los límites cuánticos (\(\pm 2\sqrt{2}\)). Puedes ver que los resultados experimentales se asemejan a la tendencia general de los resultados simulados y hay regiones donde las cantidades testigo de CHSH exceden los límites clásicos. ¡Felicidades! ¡Has demostrado con éxito el incumplimiento de la desigualdad CHSH en un sistema cuántico real!

Resumen

En este tutorial, creaste un circuito CHSH parametrizado, lo ejecutaste usando la primitiva Estimator, analizaste los resultados y demostraste el incumplimiento de la desigualdad CHSH. Puedes ver que la primitiva Estimator no solo facilita la ejecución de circuitos parametrizados, sino que también simplifica enormemente el flujo de trabajo para obtener los valores esperados de los observables.

Referencias

1. Córcoles, A. (n.d.), Local Reality and the CHSH Inequality. In A. Abbas, et al. Learn Quantum Computation Using Qiskit. URL: https://qiskit.org/textbook/ch-demos/chsh.html (accessed 07/13/2022) (2020).

Versiones de Qiskit y derechos de autor

import qiskit_ibm_runtime

qiskit_ibm_runtime.version.get_version_info()

'0.11.2'

import qiskit.tools.jupyter

%qiskit_version_table
%qiskit_copyright

Version Information

Software	Version
qiskit	0.44.0
qiskit-terra	0.25.0
qiskit_aer	0.12.2
qiskit_ibm_provider	0.6.2
qiskit_ibm_runtime	0.11.2
System information
Python version	3.11.4
Python compiler	Clang 15.0.7
Python build	main, Jun 10 2023 18:08:41
OS	Darwin
CPUs	8
Memory (Gb)	16.0
Wed Aug 02 15:00:01 2023 EDT

This code is a part of Qiskit

© Copyright IBM 2017, 2023.

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.