Spanish
Idiomas
English
Japanese
Spanish
Table of Contents

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.

El incumplimiento de la desigualdad CHSH se usa para mostrar que la mecánica cuántica es incompatible con las teorías de variables ocultas locales. Este es un experimento importante para comprender los fundamentos de la mecánica cuántica. Demostrar esto en una computadora cuántica fue un gran avance científico digno de una publicación de alto impacto hace solo unos años. [1] Es realmente increíble que puedas realizar este experimento desde la comodidad de su hogar utilizando Qiskit y un sistema IBM Quantum.

Antes de comenzar

Este tutorial requiere una instancia del servicio Qiskit Runtime. Si aún no lo has hecho, sigue las instrucciones de la guía de Primeros pasos de Qiskit para configurar uno.

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.

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.

[1]:

from qiskit.circuit import Parameter
from qiskit import QuantumCircuit

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

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

[1]:
../_images/tutorials_chsh_with_estimator_8_0.png

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\).

[2]:

import numpy as np

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]

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

Conéctate al servicio Qiskit Runtime

Antes de ejecutar los circuitos, debes conectarte a la instancia del servicio Qiskit Runtime que creaste en el primer paso. Ejecutaremos este tutorial en un simulador.

[3]:

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = "ibmq_qasm_simulator"  # use the simulator

Ejecuta los circuitos parametrizados usando la primitiva Estimator

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\).

[4]:

from qiskit_ibm_runtime import Estimator, Session
from qiskit.quantum_info import SparsePauliOp

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]
chsh_est_sim = []

# Simulator
with Session(service=service, backend=backend):
    estimator = Estimator()
    for op in ops:
        job = estimator.run(
            circuits=[chsh_circuits_no_meas] * len(individual_phases),
            observables=[op] * len(individual_phases),
            parameter_values=individual_phases,
        )
        est_result = job.result()
        chsh_est_sim.append(est_result)

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.

[5]:

# <CHSH1> = <AB> - <Ab> + <aB> + <ab>
chsh1_est_sim = (
    chsh_est_sim[0].values
    - chsh_est_sim[1].values
    + chsh_est_sim[2].values
    + chsh_est_sim[3].values
)

# <CHSH2> = <AB> + <Ab> - <aB> + <ab>
chsh2_est_sim = (
    chsh_est_sim[0].values
    + chsh_est_sim[1].values
    - chsh_est_sim[2].values
    + chsh_est_sim[3].values
)

¡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.

[6]:

import matplotlib.pyplot as plt
import matplotlib.ticker as tck

fig, ax = plt.subplots(figsize=(10, 6))
# results from a simulator
ax.plot(phases / np.pi, chsh1_est_sim, "o-", label="CHSH1 Simulation")
ax.plot(phases / np.pi, chsh2_est_sim, "o-", label="CHSH2 Simulation")
# classical bound +-2
ax.axhline(y=2, color="r", linestyle="--")
ax.axhline(y=-2, color="r", linestyle="--")
# quantum bound, +-2√2
ax.axhline(y=np.sqrt(2) * 2, color="b", linestyle="-.")
ax.axhline(y=-np.sqrt(2) * 2, color="b", linestyle="-.")
# 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("Violation of CHSH Inequality")
plt.xlabel("Theta")
plt.ylabel("CHSH witness")
plt.legend()

[6]:

<matplotlib.legend.Legend at 0x7f9a93cabeb0>
../_images/tutorials_chsh_with_estimator_19_1.png

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

[7]:

import qiskit_ibm_runtime

qiskit_ibm_runtime.version.get_version_info()

[7]:

'0.7.0'

[8]:

import qiskit.tools.jupyter

%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit SoftwareVersion
qiskit-terra0.21.0
qiskit-aer0.10.4
qiskit-ibmq-provider0.19.2
qiskit0.37.0
System information
Python version3.9.12
Python compilerClang 12.0.0
Python buildmain, Apr 5 2022 01:53:17
OSDarwin
CPUs8
Memory (Gb)16.0
Thu Jul 14 14:27:57 2022 CEST

This code is a part of Qiskit

© Copyright IBM 2017, 2022.

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.