Implémentation Qiskit

Dans cette leçon, nous mettons en œuvre quelques-unes des idées de la leçon sur l'intrication en action, à l'aide de Qiskit.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-aer

from qiskit import __version__

print(__version__)

2.1.1

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram, array_to_latex
from qiskit.result import marginal_distribution
from qiskit.circuit.library import UGate
from numpy import pi, random

Voici une implémentation en circuit quantique du protocole de téléportation.

qubit = QuantumRegister(1, "Q")
ebit0 = QuantumRegister(1, "A")
ebit1 = QuantumRegister(1, "B")
a = ClassicalRegister(1, "a")
b = ClassicalRegister(1, "b")

protocol = QuantumCircuit(qubit, ebit0, ebit1, a, b)

# Prepare ebit used for teleportation
protocol.h(ebit0)
protocol.cx(ebit0, ebit1)
protocol.barrier()

# Alice's operations
protocol.cx(qubit, ebit0)
protocol.h(qubit)
protocol.barrier()

# Alice measures and sends classical bits to Bob
protocol.measure(ebit0, a)
protocol.measure(qubit, b)
protocol.barrier()

# Bob uses the classical bits to conditionally apply gates
with protocol.if_test((a, 1)):
    protocol.x(ebit1)
with protocol.if_test((b, 1)):
    protocol.z(ebit1)

display(protocol.draw(output="mpl"))

Le circuit utilise quelques fonctionnalités de Qiskit que nous n'avons pas encore vues dans les leçons précédentes, notamment les fonctions barrier et if_test. La fonction barrier crée une séparation visuelle rendant le schéma du circuit plus lisible, et elle empêche également Qiskit d'effectuer diverses simplifications et optimisations à travers la barrière lors de la compilation, quand les circuits sont exécutés sur du vrai matériel. La fonction if_test applique une opération de façon conditionnelle en fonction d'un bit ou d'un registre classique.

Le circuit initialise d'abord $(\mathsf{A},\mathsf{B})$ dans l'état $\vert \phi^+\rangle$ (ce qui ne fait pas partie du protocole lui-même), puis viennent les opérations d'Alice, ses mesures, et enfin les opérations de Bob. Pour vérifier que le protocole fonctionne correctement, nous allons appliquer une porte à qubit unique générée aléatoirement à l'état initialisé $\vert 0\rangle$ de $\mathsf{Q}$ afin d'obtenir un vecteur d'état quantique aléatoire à téléporter. En appliquant l'inverse (c'est-à-dire la transposée conjuguée) de cette porte à $\mathsf{B}$ après l'exécution du protocole, on peut vérifier que l'état a bien été téléporté en mesurant pour s'assurer qu'il est revenu à l'état $\vert 0\rangle$.

D'abord, choisissons aléatoirement une porte unitaire à qubit.

random_gate = UGate(
    theta=random.random() * 2 * pi,
    phi=random.random() * 2 * pi,
    lam=random.random() * 2 * pi,
)

display(array_to_latex(random_gate.to_matrix()))

$$\begin{bmatrix} 0.9897212158 & -0.0195080103 - 0.141673401 i \\ 0.0603319186 + 0.1296609988 i & -0.8319925233 + 0.5360378028 i \\ \end{bmatrix}$$

Nous allons maintenant créer un nouveau circuit de test qui commence par appliquer notre porte aléatoire à $\mathsf{Q},$ puis exécute le circuit de téléportation, et enfin applique l'inverse de notre porte aléatoire au qubit $\mathsf{B}$ et mesure. Le résultat devrait être $0$ avec certitude.

# Create a new circuit including the same bits and qubits used in the
# teleportation protocol.

test = QuantumCircuit(qubit, ebit0, ebit1, a, b)

# Start with the randomly selected gate on Q

test.append(random_gate, qubit)
test.barrier()

# Append the entire teleportation protocol from above.

test = test.compose(protocol)
test.barrier()

# Finally, apply the inverse of the random unitary to B and measure.

test.append(random_gate.inverse(), ebit1)
result = ClassicalRegister(1, "Result")
test.add_register(result)
test.measure(ebit1, result)

display(test.draw(output="mpl"))

Enfin, exécutons le simulateur Aer sur ce circuit et affichons un histogramme des résultats. Nous verrons les statistiques pour les trois bits classiques : le bit du bas/de gauche devrait toujours valoir $0,$ ce qui indique que le qubit $\mathsf{Q}$ a bien été téléporté dans $\mathsf{B},$ tandis que les deux autres bits devraient être à peu près uniformes.

result = AerSimulator().run(test).result()
statistics = result.get_counts()
display(plot_histogram(statistics))

On peut aussi filtrer les statistiques pour se concentrer uniquement sur le qubit de résultat du test si on le souhaite, comme ceci :

filtered_statistics = marginal_distribution(statistics, [2])
display(plot_histogram(filtered_statistics))

Codage superdense

Le codage superdense est un protocole qui, en un certain sens, vise un objectif complémentaire à celui de la téléportation. Plutôt que de permettre la transmission d'un qubit en utilisant deux bits classiques de communication (au coût d'un e-bit d'intrication), il permet la transmission de deux bits classiques en utilisant un qubit de communication quantique (toujours au coût d'un e-bit d'intrication).

Plus en détail, nous avons un émetteur (Alice) et un récepteur (Bob) qui partagent un e-bit d'intrication. Selon les conventions établies pour la leçon, cela signifie qu'Alice détient un qubit $\mathsf{A},$ Bob détient un qubit $\mathsf{B},$ et ensemble la paire $(\mathsf{A},\mathsf{B})$ est dans l'état $\vert\phi^+\rangle.$ Alice souhaite transmettre deux bits classiques à Bob, que nous noterons $c$ et $d,$ et elle y parviendra en lui envoyant un qubit.

Il est raisonnable de considérer cet exploit comme moins intéressant que celui accompli par la téléportation. L'envoi de qubits sera vraisemblablement bien plus difficile que celui de bits classiques dans un avenir prévisible, de sorte qu'échanger un qubit de communication quantique contre deux bits de communication classique, au coût d'un e-bit de surcroît, semble à peine en valoir la peine. Cependant, cela n'implique pas que le codage superdense n'est pas intéressant, car il l'est assurément.

Dans le thème de la leçon, l'une des raisons pour lesquelles le codage superdense est intéressant est qu'il démontre une utilisation concrète et (dans le contexte de la théorie de l'information) plutôt frappante de l'intrication. Un théorème célèbre de la théorie de l'information quantique, connu sous le nom du théorème de Holevo, implique que sans l'utilisation d'un état intriqué partagé, il est impossible de communiquer plus d'un bit d'information classique en envoyant un seul qubit. (Le théorème de Holevo est plus général que cela. Son énoncé précis est technique et nécessite des explications, mais c'en est une conséquence.) Ainsi, grâce au codage superdense, l'intrication partagée permet effectivement de doubler la capacité de transport d'information classique lors de l'envoi de qubits.

Protocole

Le schéma de circuit quantique suivant décrit le protocole de codage superdense :

En résumé, voici ce qu'Alice fait :

1. Si $d=1,$ Alice applique une porte $Z$ sur son qubit $\mathsf{A}$ (et si $d=0$ elle ne fait rien).

2. Si $c=1,$ Alice applique une porte $X$ sur son qubit $\mathsf{A}$ (et si $c=0$ elle ne fait rien).

Alice envoie ensuite son qubit $\mathsf{A}$ à Bob.

Ce que fait Bob à la réception du qubit $\mathsf{A}$ consiste d'abord à appliquer une porte CNOT, avec $\mathsf{A}$ comme contrôle et $\mathsf{B}$ comme cible, puis il applique une porte Hadamard à $\mathsf{A}.$ Il mesure ensuite $\mathsf{B}$ pour obtenir $c$ et $\mathsf{A}$ pour obtenir $d,$ avec des mesures en base standard dans les deux cas.

Analyse

L'idée sous-jacente à ce protocole est simple : Alice choisit effectivement quel état de Bell elle souhaite partager avec Bob, elle lui envoie son qubit, et Bob mesure pour déterminer quel état de Bell Alice a choisi.

Autrement dit, ils partagent initialement $\vert\phi^+\rangle,$ et selon les bits $c$ et $d,$ Alice laisse cet état tel quel ou le fait basculer vers l'un des autres états de Bell en appliquant $\mathbb{I},$ $X,$ $Z,$ ou $XZ$ à son qubit $\mathsf{A}.$

$$\begin{aligned} (\mathbb{I} \otimes \mathbb{I}) \vert \phi^+ \rangle & = \vert \phi^+\rangle \\ (\mathbb{I} \otimes Z) \vert \phi^+ \rangle & = \vert \phi^-\rangle \\ (\mathbb{I} \otimes X) \vert \phi^+ \rangle & = \vert \psi^+\rangle \\ (\mathbb{I} \otimes XZ) \vert \phi^+ \rangle & = \vert \psi^-\rangle \end{aligned}$$

Les actions de Bob ont les effets suivants sur les quatre états de Bell :

$$\begin{aligned} \vert \phi^+\rangle & \mapsto \vert 00\rangle\\ \vert \phi^-\rangle & \mapsto \vert 01\rangle\\ \vert \psi^+\rangle & \mapsto \vert 10\rangle\\ \vert \psi^-\rangle & \mapsto -\vert 11\rangle\\ \end{aligned}$$

Cela peut être vérifié directement en calculant les résultats des opérations de Bob sur ces états un par un.

Ainsi, lorsque Bob effectue ses mesures, il est capable de déterminer quel état de Bell Alice a choisi. Vérifier que le protocole fonctionne correctement revient à examiner chaque cas :

• Si $cd = 00,$ alors l'état de $(\mathsf{B},\mathsf{A})$ quand Bob reçoit $\mathsf{A}$ est $\vert \phi^+\rangle.$ Il transforme cet état en $\vert 00\rangle$ et obtient $cd = 00.$

• Si $cd = 01,$ alors l'état de $(\mathsf{B},\mathsf{A})$ quand Bob reçoit $\mathsf{A}$ est $\vert \phi^-\rangle.$ Il transforme cet état en $\vert 01\rangle$ et obtient $cd = 01.$

• Si $cd = 10,$ alors l'état de $(\mathsf{B},\mathsf{A})$ quand Bob reçoit $\mathsf{A}$ est $\vert \psi^+\rangle.$ Il transforme cet état en $\vert 10\rangle$ et obtient $cd = 10.$

• Si $cd = 11,$ alors l'état de $(\mathsf{B},\mathsf{A})$ quand Bob reçoit $\mathsf{A}$ est $\vert \psi^-\rangle.$ Il transforme cet état en $-\vert 11\rangle$ et obtient $cd = 11.$ (Le facteur de phase moins un n'a aucun effet ici.)

Implémentation du codage superdense

Voici une implémentation simple du codage superdense où nous spécifions le circuit lui-même en fonction des bits à transmettre. Nous allons d'abord choisir deux bits à transmettre. (Plus tard, nous les choisirons aléatoirement, mais pour l'instant nous faisons simplement un choix arbitraire.)

c = "1"
d = "0"

Maintenant, nous allons construire le circuit en conséquence. Ici, nous laisserons Qiskit utiliser les noms par défaut pour les qubits : $\mathsf{q}_0$ pour le qubit du haut et $\mathsf{q}_1$ pour celui du bas.

protocol = QuantumCircuit(2)

# Prepare ebit used for superdense coding
protocol.h(0)
protocol.cx(0, 1)
protocol.barrier()

# Alice's operations
if d == "1":
    protocol.z(0)
if c == "1":
    protocol.x(0)
protocol.barrier()

# Bob's actions
protocol.cx(0, 1)
protocol.h(0)
protocol.measure_all()

display(protocol.draw(output="mpl"))

Il n'y a pas grand-chose de nouveau ici, si ce n'est la fonction measure_all, qui mesure tous les qubits et place les résultats dans un unique registre classique (ayant donc deux bits dans ce cas).

L'exécution du simulateur Aer produit le résultat attendu.

result = AerSimulator().run(protocol).result()
statistics = result.get_counts()

for outcome, frequency in statistics.items():
    print(f"Measured {outcome} with frequency {frequency}")

display(plot_histogram(statistics))

Measured 10 with frequency 1024

Utilisons maintenant un qubit supplémentaire comme générateur de bits aléatoires — essentiellement pour lancer des pièces de monnaie équilibrées. Nous l'utiliserons pour choisir aléatoirement $c$ et $d,$ puis exécuterons le protocole de codage superdense.

rbg = QuantumRegister(1, "coin")
ebit0 = QuantumRegister(1, "A")
ebit1 = QuantumRegister(1, "B")

Alice_c = ClassicalRegister(1, "Alice c")
Alice_d = ClassicalRegister(1, "Alice d")

test = QuantumCircuit(rbg, ebit0, ebit1, Alice_d, Alice_c)

# Initialize the ebit
test.h(ebit0)
test.cx(ebit0, ebit1)
test.barrier()

# Use the 'coin' qubit twice to generate Alice's bits c and d.
test.h(rbg)
test.measure(rbg, Alice_c)
test.h(rbg)
test.measure(rbg, Alice_d)
test.barrier()

# Now the protocol runs, starting with Alice's actions, which depend
# on her bits.
with test.if_test((Alice_d, 1), label="Z"):
    test.z(ebit0)
with test.if_test((Alice_c, 1), label="X"):
    test.x(ebit0)
test.barrier()

# Bob's actions
test.cx(ebit0, ebit1)
test.h(ebit0)
test.barrier()

Bob_c = ClassicalRegister(1, "Bob c")
Bob_d = ClassicalRegister(1, "Bob d")
test.add_register(Bob_d)
test.add_register(Bob_c)
test.measure(ebit0, Bob_d)
test.measure(ebit1, Bob_c)

display(test.draw(output="mpl"))

L'exécution du simulateur Aer montre les résultats : les bits classiques d'Alice et de Bob sont toujours identiques.

result = AerSimulator().run(test).result()
statistics = result.get_counts()
display(plot_histogram(statistics))

Le jeu CHSH

Le dernier exemple abordé dans cette leçon n'est pas un protocole, mais un jeu connu sous le nom de jeu CHSH.

Quand on parle de jeu dans ce contexte, il ne s'agit pas de quelque chose destiné à être joué pour le plaisir ou le sport, mais plutôt d'une abstraction mathématique au sens de la théorie des jeux. Les abstractions mathématiques de jeux sont étudiées en économie et en informatique, par exemple, et elles sont à la fois fascinantes et utiles.

Les lettres CHSH renvoient aux auteurs — John Clauser, Michael Horne, Abner Shimony et Richard Holt — d'un article de 1969 dans lequel l'exemple a été décrit pour la première fois. Ils n'ont pas décrit l'exemple comme un jeu, mais plutôt comme une expérience. Sa description sous forme de jeu est néanmoins à la fois naturelle et intuitive.

Le jeu CHSH appartient à une classe de jeux appelés jeux non locaux. Les jeux non locaux sont incroyablement intéressants et entretiennent des liens profonds avec la physique, l'informatique et les mathématiques — recélant des mystères qui demeurent encore irrésolus. Nous commencerons cette section en expliquant ce que sont les jeux non locaux, puis nous nous concentrerons sur le jeu CHSH et ce qui le rend si intéressant.

Jeux non locaux

Un jeu non local est un jeu coopératif dans lequel deux joueurs, Alice et Bob, travaillent ensemble pour atteindre un résultat particulier. Le jeu est animé par un arbitre, qui se comporte selon des règles strictes connues d'Alice et de Bob.

Alice et Bob peuvent se préparer au jeu comme ils le souhaitent, mais une fois le jeu commencé, il leur est interdit de communiquer. On peut imaginer que le jeu se déroule dans une installation sécurisée quelconque — comme si l'arbitre jouait le rôle d'un détective et qu'Alice et Bob étaient des suspects interrogés dans des pièces séparées. Mais une autre façon d'envisager la configuration est qu'Alice et Bob sont séparés par une grande distance, et que la communication est interdite parce que la vitesse de la lumière ne le permet pas dans le temps d'exécution du jeu. Autrement dit, si Alice essaie d'envoyer un message à Bob, le jeu sera terminé avant qu'il le reçoive, et vice versa.

Le fonctionnement d'un jeu non local est que l'arbitre pose d'abord une question à Alice et à Bob chacun. On utilisera la lettre $x$ pour désigner la question d'Alice et $y$ pour désigner celle de Bob. Ici, $x$ et $y$ sont considérés comme des états classiques, et dans le jeu CHSH, $x$ et $y$ sont des bits.

L'arbitre utilise de l'aléatoire pour sélectionner ces questions. Plus précisément, il existe une probabilité $p(x,y)$ associée à chaque paire possible $(x,y)$ de questions, et l'arbitre s'est engagé à choisir les questions aléatoirement, au moment du jeu, de cette façon. Tout le monde, y compris Alice et Bob, connaît ces probabilités — mais personne ne sait précisément quelle paire $(x,y)$ sera choisie avant le début du jeu.

Après qu'Alice et Bob ont reçu leurs questions, ils doivent fournir des réponses : la réponse d'Alice est $a$ et celle de Bob est $b.$ Ces réponses sont là encore des états classiques en général, et des bits dans le jeu CHSH.

À ce stade, l'arbitre prend une décision : Alice et Bob gagnent ou perdent selon que la paire de réponses $(a,b)$ est jugée correcte pour la paire de questions $(x,y)$ conformément à un ensemble de règles fixées. Des règles différentes définissent des jeux différents, et les règles du jeu CHSH en particulier sont décrites dans la section suivante. Comme cela a déjà été suggéré, les règles sont connues de tous.

Le diagramme suivant fournit une représentation graphique des interactions.

C'est l'incertitude quant aux questions qui seront posées, et en particulier le fait que chaque joueur ignore la question de l'autre joueur, qui rend les jeux non locaux difficiles pour Alice et Bob — tout comme des suspects complices dans des pièces séparées essayant de maintenir une version cohérente des faits.

Une description précise de l'arbitre définit une instance d'un jeu non local. Cela comprend une spécification des probabilités $p(x,y)$ pour chaque paire de questions ainsi que les règles qui déterminent si chaque paire de réponses $(a,b)$ gagne ou perd pour chaque paire de questions possible $(x,y).$

Jetons un coup d'œil au jeu CHSH dans un instant, mais avant cela, reconnaissons brièvement qu'il est également intéressant de considérer d'autres jeux non locaux. En fait, c'est extrêmement intéressant ; il existe des jeux non locaux assez simples pour lesquels on ne sait pas encore avec quelle efficacité Alice et Bob peuvent jouer en utilisant l'intrication. La configuration est simple, mais la complexité est à l'œuvre — et pour certains jeux, il peut être extrêmement difficile de calculer les stratégies optimales ou quasi-optimales pour Alice et Bob. C'est là la nature étonnamment contre-intuitive du modèle des jeux non locaux.

Description du jeu CHSH

Voici la description précise du jeu CHSH, où (comme ci-dessus) $x$ est la question d'Alice, $y$ est la question de Bob, $a$ est la réponse d'Alice, et $b$ est la réponse de Bob :

• Les questions et les réponses sont toutes des bits : $x,y,a,b\in\{0,1\}.$

• L'arbitre choisit les questions $(x,y)$ uniformément au hasard. C'est-à-dire que chacune des quatre possibilités, $(0,0),$ $(0,1),$ $(1,0),$ et $(1,1),$ est sélectionnée avec une probabilité $1/4.$

• Les réponses $(a,b)$ gagnent pour les questions $(x,y)$ si $a\oplus b = x\wedge y$ et perdent sinon. Le tableau suivant exprime cette règle en listant les conditions de victoire et de défaite sur les réponses $(a,b)$ pour chaque paire de questions $(x,y).$

$$\begin{array}{ccc} (x,y) & \text{victoire} & \text{défaite} \\[1mm]\hline \rule{0mm}{4mm}(0,0) & a = b & a \neq b \\[1mm] (0,1) & a = b & a \neq b \\[1mm] (1,0) & a = b & a \neq b \\[1mm] (1,1) & a \neq b & a = b \end{array}$$

Limitation des stratégies classiques

Examinons maintenant les stratégies d'Alice et Bob dans le jeu CHSH, en commençant par les stratégies classiques.

Stratégies déterministes

Nous commençons par les stratégies déterministes, où la réponse $a$ d'Alice est une fonction de la question $x$ qu'elle reçoit, et de même la réponse $b$ de Bob est une fonction de la question $y$ qu'il reçoit. Ainsi, par exemple, on peut écrire $a(0)$ pour représenter la réponse d'Alice lorsque sa question est $0,$ et $a(1)$ pour représenter la réponse d'Alice lorsque sa question est $1.$

Aucune stratégie déterministe ne peut gagner le jeu CHSH à chaque fois. Une façon de le comprendre est simplement de parcourir une à une toutes les stratégies déterministes possibles et de vérifier que chacune d'entre elles perd pour au moins une des quatre paires de questions possibles. Alice et Bob peuvent chacun choisir parmi quatre fonctions possibles d'un bit à un bit — que nous avons rencontrées dans la leçon sur les Systèmes uniques — et il y a donc $16$ stratégies déterministes différentes à vérifier au total.

On peut également raisonner analytiquement. Si la stratégie d'Alice et Bob gagne quand $(x,y) = (0,0),$ alors il faut que $a(0) = b(0) ;$ si leur stratégie gagne quand $(x,y) = (0,1),$ alors $a(0) = b(1) ;$ et de même, si la stratégie gagne pour $(x,y)=(1,0)$ alors $a(1) = b(0).$ Donc, si leur stratégie gagne pour les trois premières possibilités, alors

$$b(1) = a(0) = b(0) = a(1).$$

Cela implique que la stratégie perd dans le dernier cas $(x,y) = (1,1),$ où gagner exige que $a(1) \neq b(1).$ Ainsi, il ne peut exister aucune stratégie déterministe qui gagne à chaque fois.

D'autre part, il est facile de trouver des stratégies déterministes qui gagnent dans trois des quatre cas, par exemple $a(0)=a(1)=b(0)=b(1)=0.$ On conclut donc que la probabilité maximale pour Alice et Bob de gagner avec une stratégie déterministe est $3/4.$

Stratégies probabilistes

Comme nous venons de le conclure, Alice et Bob ne peuvent pas faire mieux que de gagner le jeu CHSH 75 % du temps avec une stratégie déterministe. Mais qu'en est-il d'une stratégie probabiliste ? L'utilisation de l'aléatoire pourrait-elle aider Alice et Bob — y compris la possibilité d'un aléatoire partagé, où leurs choix aléatoires sont corrélés ?

Il s'avère que les stratégies probabilistes n'aident absolument pas à augmenter la probabilité de victoire d'Alice et Bob. C'est parce que toute stratégie probabiliste peut être vue alternativement comme une sélection aléatoire d'une stratégie déterministe, tout comme (comme mentionné dans la leçon sur les Systèmes uniques) les opérations probabilistes peuvent être vues comme des sélections aléatoires d'opérations déterministes. La moyenne n'est jamais supérieure au maximum, et il s'ensuit que les stratégies probabilistes n'offrent aucun avantage en termes de probabilité de victoire globale.

Ainsi, gagner avec une probabilité $3/4$ est le meilleur qu'Alice et Bob puissent faire avec n'importe quelle stratégie classique, qu'elle soit déterministe ou probabiliste.

Stratégie pour le jeu CHSH

Une question naturelle à poser à ce stade est de savoir si Alice et Bob peuvent faire mieux avec une stratégie quantique. En particulier, s'ils partagent un état quantique intriqué comme le suggère la figure suivante, qu'ils auraient pu préparer avant de jouer, peuvent-ils augmenter leur probabilité de victoire ?

La réponse est oui, et c'est là l'intérêt principal de cet exemple et ce qui le rend si fascinant. Voyons donc exactement comment Alice et Bob peuvent faire mieux dans ce jeu grâce à l'intrication.

Vecteurs et matrices nécessaires

La première chose à faire est de définir un vecteur d'état de qubit $\vert \psi_{\theta}\rangle,$ pour chaque nombre réel $\theta$ (que l'on considère comme un angle mesuré en radians) comme suit.

$$\vert\psi_{\theta}\rangle = \cos(\theta)\vert 0\rangle + \sin(\theta) \vert 1\rangle$$

Voici quelques exemples simples :

$$\begin{aligned} \vert\psi_{0}\rangle & = \vert 0\rangle \\ \vert\psi_{\pi/2}\rangle & = \vert 1\rangle \\ \vert\psi_{\pi/4}\rangle & = \vert + \rangle \\ \vert\psi_{-\pi/4}\rangle & = \vert - \rangle \end{aligned}$$

On a également les exemples suivants, qui apparaissent dans l'analyse ci-dessous :

$$\begin{aligned} \vert\psi_{-\pi/8}\rangle & = \frac{\sqrt{2 + \sqrt{2}}}{2}\vert 0\rangle -\frac{\sqrt{2 - \sqrt{2}}}{2}\vert 1\rangle \\[1mm] \vert\psi_{\pi/8}\rangle & = \frac{\sqrt{2 + \sqrt{2}}}{2}\vert 0\rangle + \frac{\sqrt{2 - \sqrt{2}}}{2}\vert 1\rangle \\[1mm] \vert\psi_{3\pi/8}\rangle & = \frac{\sqrt{2 - \sqrt{2}}}{2}\vert 0\rangle + \frac{\sqrt{2 + \sqrt{2}}}{2}\vert 1\rangle \\[1mm] \vert\psi_{5\pi/8}\rangle & = -\frac{\sqrt{2 - \sqrt{2}}}{2}\vert 0\rangle + \frac{\sqrt{2 + \sqrt{2}}}{2}\vert 1\rangle \end{aligned}$$

En regardant la forme générale, on voit que le produit intérieur entre deux de ces vecteurs obéit à la formule suivante :

$$\langle \psi_{\alpha} \vert \psi_{\beta} \rangle = \cos(\alpha)\cos(\beta) + \sin(\alpha)\sin(\beta) = \cos(\alpha-\beta). \tag{3}$$

En détail, ces vecteurs ne contiennent que des nombres réels, donc il n'y a pas de conjugués complexes à prendre en compte : le produit intérieur est le produit des cosinus plus le produit des sinus. L'utilisation de l'une des formules d'addition d'angles de la trigonométrie conduit à la simplification ci-dessus. Cette formule révèle l'interprétation géométrique du produit intérieur entre vecteurs unitaires réels comme le cosinus de l'angle entre eux.

Si on calcule le produit intérieur du produit tensoriel de deux de ces vecteurs avec l'état $\vert \phi^+\rangle,$ on obtient une expression similaire, sauf qu'elle comporte un $\sqrt{2}$ au dénominateur :

$$\langle \psi_{\alpha} \otimes \psi_{\beta} \vert \phi^+ \rangle = \frac{\cos(\alpha)\cos(\beta) + \sin(\alpha)\sin(\beta)}{\sqrt{2}} = \frac{\cos(\alpha-\beta)}{\sqrt{2}}. \tag{4}$$

L'intérêt de ce produit intérieur particulier deviendra clair sous peu, mais pour l'instant on se contente d'observer cette formule.

Ensuite, définissons une matrice unitaire $U_{\theta}$ pour chaque angle $\theta$ comme suit.

$$U_{\theta} = \vert 0 \rangle \langle \psi_{\theta} \vert + \vert 1\rangle\langle \psi_{\theta+\pi/2} \vert$$

Intuitivement, cette matrice transforme $\vert\psi_{\theta}\rangle$ en $\vert 0\rangle$ et $\vert \psi_{\theta + \pi/2}\rangle$ en $\vert 1\rangle.$ Pour vérifier qu'il s'agit bien d'une matrice unitaire, une observation clé est que les vecteurs $\vert\psi_{\theta}\rangle$ et $\vert\psi_{\theta + \pi/2}\rangle$ sont orthogonaux pour tout angle $\theta$ :

$$\langle \psi_{\theta} \vert \psi_{\theta + \pi/2} \rangle = \cos(\pi/2) = 0.$$

Ainsi, on trouve que

$$\begin{aligned} U_{\theta} U_{\theta}^{\dagger} & = \bigl(\vert 0 \rangle \langle \psi_{\theta} \vert + \vert 1\rangle\langle \psi_{\theta+\pi/2} \vert\bigr) \bigl(\vert \psi_{\theta} \rangle \langle 0 \vert + \vert \psi_{\theta+\pi/2}\rangle\langle 1 \vert\bigr) \\[1mm] & = \vert 0 \rangle \langle \psi_{\theta} \vert \psi_{\theta} \rangle \langle 0 \vert + \vert 0 \rangle \langle \psi_{\theta} \vert \psi_{\theta+\pi/2} \rangle \langle 1 \vert + \vert 1 \rangle \langle \psi_{\theta+\pi/2} \vert \psi_{\theta} \rangle \langle 0 \vert + \vert 1 \rangle \langle \psi_{\theta+\pi/2} \vert \psi_{\theta+\pi/2} \rangle \langle 1 \vert \\[1mm] & = \vert 0 \rangle \langle 0 \vert + \vert 1 \rangle \langle 1 \vert\\[1mm] & = \mathbb{I}. \end{aligned}$$

On peut également écrire cette matrice explicitement comme

$$U_{\theta} = \begin{pmatrix} \cos(\theta) & \sin(\theta)\\[1mm] \cos(\theta+ \pi/2) & \sin(\theta + \pi/2) \end{pmatrix} = \begin{pmatrix} \cos(\theta) & \sin(\theta)\\[1mm] -\sin(\theta) & \cos(\theta) \end{pmatrix}.$$

C'est un exemple de matrice de rotation, et plus précisément elle fait tourner les vecteurs bidimensionnels à entrées réelles d'un angle $-\theta$ autour de l'origine. Si l'on suit une convention standard pour nommer et paramétrer les rotations de diverses formes, on a $U_{\theta} = R_y(-2\theta)$ où

$$R_y(\theta) = \begin{pmatrix} \cos(\theta/2) & -\sin(\theta/2)\\[1mm] \sin(\theta/2) & \cos(\theta/2) \end{pmatrix}.$$

Description de la stratégie

On peut maintenant décrire la stratégie quantique.

• Configuration : Alice et Bob commencent le jeu en partageant un e-bit : Alice détient un qubit $\mathsf{A},$ Bob détient un qubit $\mathsf{B},$ et ensemble les deux qubits $(\mathsf{X},\mathsf{Y})$ sont dans l'état $\vert\phi^+\rangle.$

• Actions d'Alice :

  • Si Alice reçoit la question $x=0,$ elle applique $U_{0}$ à son qubit $\mathsf{A}.$
  • Si Alice reçoit la question $x=1,$ elle applique $U_{\pi/4}$ à son qubit $\mathsf{A}.$

  L'opération qu'Alice effectue sur $\mathsf{A}$ peut également être décrite ainsi :

  $$\begin{cases} U_0 & \text{if $x = 0$}\\ U_{\pi/4} & \text{if $x = 1$} \end{cases}$$

  Après avoir appliqué cette opération, Alice mesure $\mathsf{A}$ avec une mesure en base standard et fixe sa réponse $a$ au résultat de la mesure.

• Actions de Bob :

  • Si Bob reçoit la question $y=0,$ il applique $U_{\pi/8}$ à son qubit $\mathsf{B}.$
  • Si Bob reçoit la question $y=1,$ il applique $U_{-\pi/8}$ à son qubit $\mathsf{B}.$

  Comme pour Alice, l'opération de Bob sur $\mathsf{B}$ peut s'exprimer ainsi :

  $$\begin{cases} U_{\pi/8} & \text{if $y = 0$}\\ U_{-\pi/8} & \text{if $y = 1$} \end{cases}$$

  Après avoir appliqué cette opération, Bob mesure $\mathsf{B}$ avec une mesure en base standard et fixe sa réponse $b$ au résultat de la mesure.

Voici un diagramme de circuit quantique décrivant cette stratégie :

Dans ce diagramme, on voit deux portes contrôlées ordinaires, l'une pour $U_{-\pi/8}$ en haut et l'autre pour $U_{\pi/4}$ en bas. On a également deux portes qui ressemblent à des portes contrôlées, l'une pour $U_{\pi/8}$ en haut et l'autre pour $U_{0}$ en bas, sauf que le cercle représentant le contrôle n'est pas rempli. Cela désigne un type différent de porte contrôlée où la porte est exécutée si le contrôle est à $0$ (plutôt qu'à $1$ comme une porte contrôlée ordinaire). Ainsi, en pratique, Bob applique $U_{\pi/8}$ à son qubit si $y=0$ et $U_{-\pi/8}$ si $y=1$ ; et Alice applique $U_0$ à son qubit si $x=0$ et $U_{\pi/4}$ si $x=1,$ ce qui est cohérent avec la description du protocole en mots ci-dessus.

Il reste à déterminer l'efficacité de cette stratégie pour Alice et Bob. On le fera en passant en revue les quatre paires de questions possibles individuellement.

Analyse cas par cas

• Cas 1 : $(x,y) = (0,0).$

  Dans ce cas, Alice applique $U_{0}$ à son qubit et Bob applique $U_{\pi/8}$ au sien, donc l'état des deux qubits $(\mathsf{A},\mathsf{B})$ après qu'ils ont effectué leurs opérations est

  $$\begin{aligned} \bigl(U_0 \otimes U_{\pi/8}\bigr) \vert \phi^+\rangle & = \vert 00 \rangle \langle \psi_0 \otimes \psi_{\pi/8}\vert \phi^+\rangle + \vert 01 \rangle \langle \psi_0 \otimes\psi_{5\pi/8}\vert \phi^+\rangle \\ & \qquad + \vert 10 \rangle \langle \psi_{\pi/2} \otimes \psi_{\pi/8}\vert \phi^+\rangle + \vert 11 \rangle \langle \psi_{\pi/2} \otimes \psi_{5\pi/8}\vert \phi^+\rangle\\[2mm] & = \frac{ \cos\bigl(-\frac{\pi}{8}\bigr) \vert 00\rangle + \cos\bigl(-\frac{5\pi}{8}\bigr) \vert 01\rangle + \cos\bigl(\frac{3\pi}{8}\bigr) \vert 10\rangle + \cos\bigl(-\frac{\pi}{8}\bigr) \vert 11\rangle}{\sqrt{2}}. \end{aligned}$$

  Les probabilités pour les quatre paires de réponses possibles $(a,b)$ sont donc les suivantes.

  $$\begin{aligned} \operatorname{Pr}\bigl((a,b)=(0,0)\bigr) & = \frac{1}{2}\cos^2\Bigl(-\frac{\pi}{8}\Bigr) = \frac{2+\sqrt{2}}{8} \\[2mm] \operatorname{Pr}\bigl((a,b)=(0,1)\bigr) & = \frac{1}{2}\cos^2\Bigl(-\frac{5\pi}{8}\Bigr) = \frac{2-\sqrt{2}}{8}\\[2mm] \operatorname{Pr}\bigl((a,b)=(1,0)\bigr) & = \frac{1}{2}\cos^2\Bigl(\frac{3\pi}{8}\Bigr) = \frac{2-\sqrt{2}}{8}\\[2mm] \operatorname{Pr}\bigl((a,b)=(1,1)\bigr) & = \frac{1}{2}\cos^2\Bigl(-\frac{\pi}{8}\Bigr) = \frac{2+\sqrt{2}}{8} \end{aligned}$$

  On peut ensuite obtenir les probabilités que $a=b$ et $a\neq b$ en faisant la somme.

  $$\begin{aligned} \operatorname{Pr}(a = b) & = \frac{2 + \sqrt{2}}{4}\\[2mm] \operatorname{Pr}(a \neq b) & = \frac{2 - \sqrt{2}}{4} \end{aligned}$$

  Pour la paire de questions $(0,0),$ Alice et Bob gagnent si $a=b,$ et donc ils gagnent dans ce cas avec une probabilité de

  $$\frac{2 + \sqrt{2}}{4}.$$

• Cas 2 : $(x,y) = (0,1).$

  Dans ce cas, Alice applique $U_{0}$ à son qubit et Bob applique $U_{-\pi/8}$ au sien, donc l'état des deux qubits $(\mathsf{A},\mathsf{B})$ après qu'ils ont effectué leurs opérations est

  $$\begin{aligned} \bigl(U_0 \otimes U_{-\pi/8}\bigr) \vert \phi^+\rangle & = \vert 00 \rangle \langle \psi_0 \otimes \psi_{-\pi/8}\vert \phi^+\rangle + \vert 01 \rangle \langle \psi_0 \otimes\psi_{3\pi/8}\vert \phi^+\rangle \\ & \qquad + \vert 10 \rangle \langle \psi_{\pi/2} \otimes \psi_{-\pi/8}\vert \phi^+\rangle + \vert 11 \rangle \langle \psi_{\pi/2} \otimes \psi_{3\pi/8}\vert \phi^+\rangle\\[2mm] & = \frac{ \cos\bigl(\frac{\pi}{8}\bigr) \vert 00\rangle + \cos\bigl(-\frac{3\pi}{8}\bigr) \vert 01\rangle + \cos\bigl(\frac{5\pi}{8}\bigr) \vert 10\rangle + \cos\bigl(\frac{\pi}{8}\bigr) \vert 11\rangle}{\sqrt{2}}. \end{aligned}$$

  Les probabilités pour les quatre paires de réponses possibles $(a,b)$ sont donc les suivantes.

  $$\begin{aligned} \operatorname{Pr}\bigl((a,b)=(0,0)\bigr) & = \frac{1}{2}\cos^2\Bigl(\frac{\pi}{8}\Bigr) = \frac{2+\sqrt{2}}{8} \\[2mm] \operatorname{Pr}\bigl((a,b)=(0,1)\bigr) & = \frac{1}{2}\cos^2\Bigl(-\frac{3\pi}{8}\Bigr) = \frac{2-\sqrt{2}}{8}\\[2mm] \operatorname{Pr}\bigl((a,b)=(1,0)\bigr) & = \frac{1}{2}\cos^2\Bigl(\frac{5\pi}{8}\Bigr) = \frac{2-\sqrt{2}}{8}\\[2mm] \operatorname{Pr}\bigl((a,b)=(1,1)\bigr) & = \frac{1}{2}\cos^2\Bigl(\frac{\pi}{8}\Bigr) = \frac{2+\sqrt{2}}{8} \end{aligned}$$

On peut à nouveau obtenir les probabilités que $a=b$ et $a\neq b$ par sommation.

$$\begin{aligned} \operatorname{Pr}(a = b) & = \frac{2 + \sqrt{2}}{4}\\[2mm] \operatorname{Pr}(a \neq b) & = \frac{2 - \sqrt{2}}{4} \end{aligned}$$

Pour la paire de questions $(0,1),$ Alice et Bob gagnent si $a=b,$ et donc ils gagnent dans ce cas avec la probabilité

$$\frac{2 + \sqrt{2}}{4}.$$

• Cas 3 : $(x,y) = (1,0).$

  Dans ce cas, Alice applique $U_{\pi/4}$ sur son qubit et Bob applique $U_{\pi/8}$ sur le sien, donc l'état des deux qubits $(\mathsf{A},\mathsf{B})$ après qu'ils ont effectué leurs opérations est

  $$\begin{aligned} \bigl(U_{\pi/4} \otimes U_{\pi/8}\bigr) \vert \phi^+\rangle & = \vert 00 \rangle \langle \psi_{\pi/4} \otimes \psi_{\pi/8}\vert \phi^+\rangle + \vert 01 \rangle \langle \psi_{\pi/4} \otimes\psi_{5\pi/8}\vert \phi^+\rangle \\ & \qquad + \vert 10 \rangle \langle \psi_{3\pi/4} \otimes \psi_{\pi/8}\vert \phi^+\rangle + \vert 11 \rangle \langle \psi_{3\pi/4} \otimes \psi_{5\pi/8}\vert \phi^+\rangle\\[2mm] & = \frac{ \cos\bigl(\frac{\pi}{8}\bigr) \vert 00\rangle + \cos\bigl(-\frac{3\pi}{8}\bigr) \vert 01\rangle + \cos\bigl(\frac{5\pi}{8}\bigr) \vert 10\rangle + \cos\bigl(\frac{\pi}{8}\bigr) \vert 11\rangle}{\sqrt{2}}. \end{aligned}$$

  Les probabilités pour les quatre paires de réponses possibles $(a,b)$ sont donc les suivantes.

  $$\begin{aligned} \operatorname{Pr}\bigl((a,b)=(0,0)\bigr) & = \frac{1}{2}\cos^2\Bigl(\frac{\pi}{8}\Bigr) = \frac{2+\sqrt{2}}{8} \\[2mm] \operatorname{Pr}\bigl((a,b)=(0,1)\bigr) & = \frac{1}{2}\cos^2\Bigl(-\frac{3\pi}{8}\Bigr) = \frac{2-\sqrt{2}}{8}\\[2mm] \operatorname{Pr}\bigl((a,b)=(1,0)\bigr) & = \frac{1}{2}\cos^2\Bigl(\frac{5\pi}{8}\Bigr) = \frac{2-\sqrt{2}}{8}\\[2mm] \operatorname{Pr}\bigl((a,b)=(1,1)\bigr) & = \frac{1}{2}\cos^2\Bigl(\frac{\pi}{8}\Bigr) = \frac{2+\sqrt{2}}{8} \end{aligned}$$

  On retrouve, une fois encore, que les probabilités que $a=b$ et $a\neq b$ sont les suivantes.

  $$\begin{aligned} \operatorname{Pr}(a = b) & = \frac{2 + \sqrt{2}}{4}\\[2mm] \operatorname{Pr}(a \neq b) & = \frac{2 - \sqrt{2}}{4} \end{aligned}$$

  Pour la paire de questions $(1,0),$ Alice et Bob gagnent si $a=b,$ donc ils gagnent dans ce cas avec la probabilité

  $$\frac{2 + \sqrt{2}}{4}.$$

• Cas 4 : $(x,y) = (1,1).$

  Ce dernier cas est un peu différent, ce qu'on pouvait anticiper car la condition de victoire y est différente. Lorsque $x$ et $y$ valent tous les deux $1,$ Alice et Bob gagnent quand $a$ et $b$ sont différents. Dans ce cas, Alice applique $U_{\pi/4}$ sur son qubit et Bob applique $U_{-\pi/8}$ sur le sien, donc l'état des deux qubits $(\mathsf{A},\mathsf{B})$ après leurs opérations est

  $$\begin{aligned} \bigl(U_{\pi/4} \otimes U_{-\pi/8}\bigr) \vert \phi^+\rangle & = \vert 00 \rangle \langle \psi_{\pi/4} \otimes \psi_{-\pi/8}\vert \phi^+\rangle + \vert 01 \rangle \langle \psi_{\pi/4} \otimes\psi_{3\pi/8}\vert \phi^+\rangle \\ & \qquad + \vert 10 \rangle \langle \psi_{3\pi/4} \otimes \psi_{-\pi/8}\vert \phi^+\rangle + \vert 11 \rangle \langle \psi_{3\pi/4} \otimes \psi_{3\pi/8}\vert \phi^+\rangle\\[2mm] & = \frac{ \cos\bigl(\frac{3\pi}{8}\bigr) \vert 00\rangle + \cos\bigl(-\frac{\pi}{8}\bigr) \vert 01\rangle + \cos\bigl(\frac{7\pi}{8}\bigr) \vert 10\rangle + \cos\bigl(\frac{3\pi}{8}\bigr) \vert 11\rangle}{\sqrt{2}}. \end{aligned}$$

  Les probabilités pour les quatre paires de réponses possibles $(a,b)$ sont donc les suivantes.

  $$\begin{aligned} \operatorname{Pr}\bigl((a,b)=(0,0)\bigr) & = \frac{1}{2}\cos^2\Bigl(\frac{3\pi}{8}\Bigr) = \frac{2-\sqrt{2}}{8} \\[2mm] \operatorname{Pr}\bigl((a,b)=(0,1)\bigr) & = \frac{1}{2}\cos^2\Bigl(-\frac{\pi}{8}\Bigr) = \frac{2+\sqrt{2}}{8}\\[2mm] \operatorname{Pr}\bigl((a,b)=(1,0)\bigr) & = \frac{1}{2}\cos^2\Bigl(\frac{7\pi}{8}\Bigr) = \frac{2+\sqrt{2}}{8}\\[2mm] \operatorname{Pr}\bigl((a,b)=(1,1)\bigr) & = \frac{1}{2}\cos^2\Bigl(\frac{3\pi}{8}\Bigr) = \frac{2-\sqrt{2}}{8} \end{aligned}$$

  Les probabilités ont effectivement échangé leurs places par rapport aux trois autres cas. On obtient les probabilités que $a=b$ et $a\neq b$ par sommation.

  $$\begin{aligned} \operatorname{Pr}(a = b) & = \frac{2 - \sqrt{2}}{4}\\[2mm] \operatorname{Pr}(a \neq b) & = \frac{2 + \sqrt{2}}{4} \end{aligned}$$

  Pour la paire de questions $(1,1),$ Alice et Bob gagnent si $a\neq b,$ et donc ils gagnent dans ce cas avec la probabilité

  $$\frac{2 + \sqrt{2}}{4}.$$

Ils gagnent dans chaque cas avec la même probabilité :

$$\frac{2 + \sqrt{2}}{4} \approx 0.85.$$

C'est donc la probabilité qu'ils gagnent globalement. C'est nettement mieux que ce que peut faire n'importe quelle stratégie classique pour ce jeu ; les stratégies classiques ont une probabilité de victoire bornée par $3/4.$ Et cela en fait un exemple très intéressant.

Il se trouve que c'est la probabilité de victoire optimale pour les stratégies quantiques ; on ne peut pas faire mieux, quels que soient l'état intriqué ou les mesures choisis. Ce fait est connu sous le nom d'inégalité de Tsirelson, du nom de Boris Tsirelson qui l'a prouvée en premier — et qui a le premier décrit l'expérience CHSH comme un jeu.

Image géométrique

Il est possible de penser géométriquement à la stratégie décrite ci-dessus, ce qui peut aider à comprendre les relations entre les différents angles choisis pour les opérations d'Alice et de Bob.

Ce qu'Alice fait effectivement, c'est choisir un angle $\alpha,$ en fonction de sa question $x,$ puis appliquer $U_{\alpha}$ à son qubit et mesurer. De même, Bob choisit un angle $\beta,$ en fonction de $y,$ puis il applique $U_{\beta}$ à son qubit et mesure. Nous avons choisi $\alpha$ et $\beta$ comme suit.

$$\begin{aligned} \alpha & = \begin{cases} 0 & x=0\\ \pi/4 & x=1 \end{cases}\\[4mm] \beta & = \begin{cases} \pi/8 & y = 0\\ -\pi/8 & y = 1 \end{cases} \end{aligned}$$

Pour l'instant, prenons $\alpha$ et $\beta$ comme étant arbitraires. En choisissant $\alpha,$ Alice définit effectivement une base orthonormée de vecteurs qui ressemble à ceci :

Bob fait de même, sauf que son angle est $\beta$ :

Les couleurs des vecteurs correspondent aux réponses d'Alice et de Bob : bleu pour $0$ et rouge pour $1.$

Maintenant, si on combine ($3$) et ($4$) on obtient la formule

$$\langle \psi_{\alpha} \otimes\psi_{\beta} \vert \phi^+ \rangle = \frac{1}{\sqrt{2}} \langle \psi_{\alpha} \vert \psi_{\beta} \rangle;$$

cela vaut pour tous les nombres réels $\alpha$ et $\beta.$

En suivant le même type d'analyse que ci-dessus, mais avec $\alpha$ et $\beta$ comme variables, on obtient :

$$\begin{aligned} & \bigl(U_{\alpha} \otimes U_{\beta}\bigr) \vert \phi^+\rangle\\[1mm] & \qquad = \vert 00 \rangle \langle \psi_{\alpha} \otimes \psi_{\beta}\vert \phi^+\rangle + \vert 01 \rangle \langle \psi_{\alpha} \otimes\psi_{\beta + \pi/2}\vert \phi^+\rangle \\ & \qquad \qquad + \vert 10 \rangle \langle \psi_{\alpha+\pi/2} \otimes \psi_{\beta}\vert \phi^+\rangle + \vert 11 \rangle \langle \psi_{\alpha+\pi/2} \otimes \psi_{\beta+\pi/2}\vert \phi^+\rangle\\[2mm] & \qquad = \frac{ \langle \psi_\alpha \vert \psi_\beta \rangle \vert 00\rangle + \langle \psi_\alpha \vert \psi_{\beta+\pi/2} \rangle \vert 01\rangle + \langle \psi_{\alpha+\pi/2} \vert \psi_\beta \rangle \vert 10\rangle + \langle \psi_{\alpha+\pi/2} \vert \psi_{\beta+\pi/2} \rangle \vert 11\rangle }{\sqrt{2}}. \end{aligned}$$

On en déduit ces deux formules :

$$\begin{aligned} \operatorname{Pr}(a = b) & = \frac{1}{2} \vert \langle \psi_\alpha \vert \psi_\beta \rangle \vert^2 + \frac{1}{2} \vert \langle \psi_{\alpha+\pi/2} \vert \psi_{\beta+\pi/2} \rangle \vert^2 = \cos^2(\alpha - \beta)\\[2mm] \operatorname{Pr}(a \neq b) & = \frac{1}{2} \vert \langle \psi_\alpha \vert \psi_{\beta+\pi/2} \rangle \vert^2 + \frac{1}{2} \vert \langle \psi_{\alpha+\pi/2} \vert \psi_\beta \rangle \vert^2 = \sin^2(\alpha - \beta). \end{aligned}$$

Ces équations peuvent être reliées aux figures ci-dessus en imaginant qu'on superpose les bases choisies par Alice et Bob.

Explorer la stratégie

Quand $(x,y) = (0,0),$ Alice et Bob choisissent $\alpha = 0$ et $\beta = \pi/8,$ et en superposant leurs bases on obtient cette figure :

L'angle entre les vecteurs rouges est $\pi/8,$ ce qui est le même que l'angle entre les deux vecteurs bleus. La probabilité que les résultats d'Alice et Bob coïncident est le cosinus carré de cet angle,

$$\cos^2\Bigl(\frac{\pi}{8}\Bigr) = \frac{2 + \sqrt{2}}{4},$$

tandis que la probabilité qu'ils divergent est le sinus carré de cet angle,

$$\sin^2\Bigl(\frac{\pi}{8}\Bigr) = \frac{2 - \sqrt{2}}{4}.$$

Quand $(x,y) = (0,1),$ Alice et Bob choisissent $\alpha = 0$ et $\beta = -\pi/8,$ et en superposant leurs bases on obtient cette figure :

L'angle entre les vecteurs rouges est à nouveau $\pi/8,$ tout comme l'angle entre les vecteurs bleus. La probabilité que les résultats d'Alice et Bob coïncident est à nouveau le cosinus carré de cet angle,

$$\cos^2\Bigl(\frac{\pi}{8}\Bigr) = \frac{2 + \sqrt{2}}{4},$$

tandis que la probabilité qu'ils divergent est le sinus carré de cet angle,

$$\sin^2\Bigl(\frac{\pi}{8}\Bigr) = \frac{2 - \sqrt{2}}{4}.$$

Quand $(x,y) = (1,0),$ Alice et Bob choisissent $\alpha = \pi/4$ et $\beta = \pi/8,$ et en superposant leurs bases on obtient cette figure :

Les bases ont changé mais pas les angles — l'angle entre les vecteurs de même couleur est encore $\pi/8.$ La probabilité que les résultats d'Alice et Bob coïncident est

$$\cos^2\Bigl(\frac{\pi}{8}\Bigr) = \frac{2 + \sqrt{2}}{4},$$

et la probabilité qu'ils divergent est

$$\sin^2\Bigl(\frac{\pi}{8}\Bigr) = \frac{2 - \sqrt{2}}{4}.$$

Quand $(x,y) = (1,1),$ Alice et Bob choisissent $\alpha = \pi/4$ et $\beta = -\pi/8.$ Lorsqu'on superpose leurs bases, on voit que quelque chose de différent s'est produit :

De par la façon dont les angles ont été choisis, l'angle entre les vecteurs de même couleur est cette fois $3\pi/8$ et non $\pi/8.$ La probabilité que les résultats d'Alice et Bob coïncident est toujours le cosinus carré de cet angle, mais cette fois la valeur est

$$\cos^2\Bigl(\frac{3\pi}{8}\Bigr) = \frac{2 - \sqrt{2}}{4}.$$

La probabilité que les résultats divergent est le sinus carré de cet angle, qui vaut dans ce cas :

$$\sin^2\Bigl(\frac{3\pi}{8}\Bigr) = \frac{2 + \sqrt{2}}{4}.$$

Remarques

L'idée de base d'une expérience comme le jeu CHSH, où l'intrication conduit à des résultats statistiques incompatibles avec un raisonnement purement classique, est due à John Bell, le homonyme des états de Bell. C'est pourquoi on désigne souvent ce type d'expériences sous le nom de tests de Bell. On parle aussi parfois du théorème de Bell, qui peut être formulé de différentes manières — mais dont l'essence est que la mécanique quantique est incompatible avec les théories dites à variables cachées locales. Le jeu CHSH est un exemple particulièrement propre et simple de test de Bell, et peut être vu comme une preuve, ou démonstration, du théorème de Bell.

Le jeu CHSH offre un moyen de tester expérimentalement la théorie de l'information quantique. On peut réaliser des expériences qui implémentent le jeu CHSH, et tester les types de stratégies basées sur l'intrication décrites ci-dessus. Cela nous donne un haut degré de confiance dans le fait que l'intrication est réelle — et contrairement aux façons parfois vagues ou poétiques que nous trouvons pour expliquer l'intrication, le jeu CHSH nous offre un moyen concret et testable d'observer l'intrication. Le prix Nobel de physique 2022 reconnaît l'importance de ce domaine de recherche : le prix a été décerné à Alain Aspect, John Clauser (le C de CHSH), et Anton Zeilinger, pour avoir observé l'intrication via des tests de Bell sur des photons intriqués.

Implémentation Qiskit

On peut implémenter le jeu CHSH, ainsi que la stratégie quantique définie ci-dessus, dans Qiskit comme suit.

Voici d'abord la définition du jeu lui-même, qui permet de brancher une stratégie arbitraire en argument.

def chsh_game(strategy):
    # This function runs the CHSH game, using the strategy (a function
    # from two bits to two bits), returning 1 for a win and 0 for a loss.

    # Choose x and y randomly
    x, y = random.randint(0, 1), random.randint(0, 1)

    # Use the strategy to determine a and b
    a, b = strategy(x, y)

    # Decide if the strategy wins or loses
    if (a != b) == (x & y):
        return 1  # Win
    return 0  # Lose

On va maintenant créer une fonction qui produit un circuit en fonction des questions posées à Alice et Bob. Pour simplifier, on laissera les qubits avec leurs noms par défaut, et on utilisera la porte $R_y(\theta)$ intégrée pour les actions d'Alice et de Bob.

def chsh_circuit(x, y):
    # This function creates a `QuantumCircuit` implementing the quantum
    # strategy described above (including the e-bit preparation).

    qc = QuantumCircuit(2, 2)

    # Prepare an e-bit
    qc.h(0)
    qc.cx(0, 1)
    qc.barrier()

    # Alice's actions
    if x == 0:
        qc.ry(0, 0)
    else:
        qc.ry(-pi / 2, 0)
    qc.measure(0, 0)

    # Bob's actions
    if y == 0:
        qc.ry(-pi / 4, 1)
    else:
        qc.ry(pi / 4, 1)
    qc.measure(1, 1)

    return qc

Voici les quatre circuits possibles, selon les questions posées.

# Draw the four possible circuits

print("(x,y) = (0,0)")
display(chsh_circuit(0, 0).draw(output="mpl"))

print("(x,y) = (0,1)")
display(chsh_circuit(0, 1).draw(output="mpl"))

print("(x,y) = (1,0)")
display(chsh_circuit(1, 0).draw(output="mpl"))

print("(x,y) = (1,1)")
display(chsh_circuit(1, 1).draw(output="mpl"))

(x,y) = (0,0)

(x,y) = (0,1)

(x,y) = (1,0)

(x,y) = (1,1)

On va maintenant créer un job avec le simulateur Aer qui exécute le circuit une seule fois pour une paire d'entrées $(x,y)$ donnée.

def quantum_strategy(x, y):
    # This function runs the appropriate quantum circuit defined above
    # one time and returns the measurement results

    # Setting `shots=1` to run the circuit once
    result = AerSimulator().run(chsh_circuit(x, y), shots=1).result()
    statistics = result.get_counts()

    # Determine the output bits and return them
    bits = list(statistics.keys())[0]
    a, b = bits[0], bits[1]
    return a, b

Enfin, on va jouer 1000 fois et calculer la fraction de parties gagnées par la stratégie.

NUM_GAMES = 1000
TOTAL_SCORE = 0

for _ in range(NUM_GAMES):
    TOTAL_SCORE += chsh_game(quantum_strategy)

print("Fraction of games won:", TOTAL_SCORE / NUM_GAMES)

Fraction of games won: 0.867

On peut aussi définir une stratégie classique et voir comment elle se comporte. Ce n'est qu'une stratégie parmi d'autres — on peut en tester d'autres en modifiant le code — mais elle fait partie des stratégies classiques optimales.

def classical_strategy(x, y):
    # This function implements just one example of an optimal classical
    # strategy for the CHSH game. Other classical strategies can be
    # implemented by changing the bit values assigned to a and b.

    # Alice's answer
    if x == 0:
        a = 0
    elif x == 1:
        a = 1

    # Bob's answer
    if y == 0:
        b = 1
    elif y == 1:
        b = 0

    return a, b

Jouons à nouveau 1000 parties pour voir comment elle se comporte.

NUM_GAMES = 1000
TOTAL_SCORE = 0

for _ in range(NUM_GAMES):
    TOTAL_SCORE += chsh_game(classical_strategy)

print("Fraction of games won:", TOTAL_SCORE / NUM_GAMES)

Fraction of games won: 0.747