Teletrasporto quantistico

Per questo modulo Qiskit in Classrooms, gli studenti devono disporre di un ambiente Python funzionante con i seguenti pacchetti installati:

• qiskit v2.1.0 o versione più recente
• qiskit-ibm-runtime v0.40.1 o versione più recente
• qiskit-aer v0.17.0 o versione più recente
• qiskit.visualization
• numpy
• pylatexenc

Per configurare e installare i pacchetti sopra indicati, consulta la guida Installare Qiskit. Per eseguire job su veri computer quantistici, gli studenti dovranno creare un account IBM Quantum® seguendo i passaggi della guida Configura il tuo account IBM Cloud.

Questo modulo è stato testato e ha utilizzato 14 secondi di tempo QPU. Si tratta solo di una stima. Il tuo utilizzo effettivo può variare.

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

# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

Guarda il tutorial del modulo della Dr. Katie McCormick qui sotto, oppure clicca qui per guardarlo su YouTube.

---

Introduzione e contesto

Il teletrasporto quantistico è una tecnica della fisica quantistica che consente di trasferire informazioni quantistiche da una posizione a un'altra senza spostare fisicamente le particelle. A differenza del concetto fantascentifico di teletrasporto, questo processo non comporta il trasporto di materia. Si basa invece sul principio dell'entanglement quantistico, secondo cui due particelle diventano collegate indipendentemente dalla distanza. Attraverso una serie di misurazioni precise e comunicazioni classiche, lo stato quantistico di una particella può essere ricreato in un'altra particella in una posizione distante, "teletrasportando" di fatto le informazioni quantistiche. In questo modulo vedremo come funziona matematicamente, e poi implementeremo il teletrasporto quantistico su un vero computer quantistico. L'introduzione qui sarà breve; per approfondire le informazioni quantistiche e avere ulteriori spiegazioni sul teletrasporto, consigliamo il corso di John Watrous sulle Basi dell'informazione quantistica, e in particolare la sezione sul Teletrasporto.

I bit classici possono trovarsi negli stati 0 o 1. I bit quantistici (qubit) possono trovarsi in stati quantistici indicati con $|0\rangle$ e $|1\rangle$ e anche in combinazioni lineari di questi stati, chiamate "sovrapposizioni", come $|\psi\rangle = \alpha_0|0\rangle +\alpha_1|1\rangle$, con $\alpha_0,\alpha_1 \in \mathbb{C},$ e $|\alpha_0|^2+|\alpha_1|^2 = 1.$ Sebbene gli stati possano esistere in questa sovrapposizione, una misurazione dello stato lo "collasserà" nello stato $|0\rangle$ o $|1\rangle$. I parametri $a$ e $b$ sono legati alla probabilità di ciascun risultato di misurazione secondo

$$P_0 = |\alpha_0|^2$$ $$P_1 = |\alpha_1|^2$$

Da cui il vincolo che $|\alpha_0|^2+|\alpha_1|^2 = 1.$

Un'altra caratteristica fondamentale è che i bit quantistici possono essere "entangled" (intrecciati), il che significa che la misurazione di un qubit può influenzare il risultato della misurazione di un altro qubit entangled. Capire in cosa l'entanglement differisce dalle semplici correlazioni classiche è un po' complicato. Prima di tutto, spieghiamo la nostra notazione. Consideriamo due qubit appartenenti all'amico 0 (Alice) e all'amico 1 (Bob), entrambi nello stato $|0\rangle$

$$|0\rangle_B|0\rangle_A$$

oppure

$$|0\rangle_1|0\rangle_0$$

a volte abbreviato semplicemente come

$$|00\rangle$$

Nota che il qubit con il numero (o la lettera) più basso si trova più a destra. Questa è una convenzione chiamata notazione "little-endian", utilizzata in tutto Qiskit. Se lo stato a due qubit degli amici è $|00\rangle,$ e misurano lo stato dei rispettivi qubit, troveranno entrambi un 0. Analogamente, se i qubit fossero nello stato $|11\rangle,$ ciascuna delle loro misurazioni darebbe un 1. Questo non è diverso dal caso classico. Tuttavia, nel quantum computing possiamo combinare questo con la sovrapposizione per ottenere stati come

$$\frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$$

In uno stato di questo tipo, se i qubit di Alice e Bob si trovino nello stato 0 o 1 non è ancora noto, nemmeno ancora determinato dalla natura, eppure sappiamo che misureranno lo stesso stato per il loro qubit. Ad esempio, se Bob misura il suo qubit e lo trova nello stato $|0\rangle,$ l'unico modo in cui ciò possa avvenire è che la misurazione abbia collassato lo stato a due qubit in uno dei due stati possibili, specificamente in $|00\rangle.$ Questo lascia anche il qubit di Alice nello stato $|0\rangle$.

L'entanglement dei qubit in questo modo non richiede che i qubit rimangano fisicamente vicini l'uno all'altro. In altre parole, potremmo fare l'entanglement dei qubit, poi separarli di una grande distanza, e usare il loro entanglement per inviare informazioni. Uno stato entangled come quello sopra è un'unità di base di entanglement, a volte indicato come "e-bit", un singolo bit di entanglement. Questi e-bit possono essere considerati come risorse nella comunicazione quantistica, poiché ogni e-bit condiviso tra partner distanti può essere utilizzato, come descriviamo qui, per spostare informazioni da una posizione a un'altra.

Il primo pensiero di molte persone che apprendono questo per la prima volta riguarda la violazione della relatività: possiamo usarlo per inviare informazioni più velocemente della luce? Assolutamente, continua a interrogarti e a mettere alla prova le regole scientifiche, ma purtroppo questo non ci permetterà di inviare informazioni più velocemente della luce, per ragioni che diventeranno chiare nel corso di questo modulo. Anticipazione: incredibilmente questo NON è dovuto alla velocità con cui si propaga questo collasso, che sembra avvenire più velocemente della luce [1]. Iniziamo con due collaboratori Alice e Bob, che si trovano inizialmente nella stessa posizione e possono lavorare insieme sugli stessi qubit. Questi collaboratori faranno l'entanglement dei loro qubit. Poi si separeranno in due diverse posizioni geografiche, portando con sé i rispettivi qubit. Alice otterrà quindi informazioni quantistiche su un nuovo qubit Q. Non facciamo alcuna assunzione sulle informazioni contenute in Q. Lo stato di Q potrebbe essere un segreto sconosciuto ad Alice; potrebbe essere sconosciuto a tutti. Ma ad Alice viene affidato il compito di trasferire le informazioni su Q a Bob. Lo farà usando il teletrasporto quantistico.

Per realizzare questo, dovremo conoscere alcune operazioni quantistiche o "gate".

Operatori quantistici (gate)

Puoi tranquillamente saltare questa sezione se hai già familiarità con i gate quantistici. Se vuoi capire meglio questi gate, consulta le Basi dell'informazione quantistica, in particolare le prime due lezioni, su IBM Quantum Learning.

Per questo protocollo di teletrasporto utilizzeremo principalmente due tipi di gate quantistici: il gate Hadamard e il gate CNOT. Altri gate avranno un ruolo minore: il gate $X$, il gate $Z$ e il gate SWAP.

Questo modulo può essere completato con una conoscenza molto limitata di algebra lineare, ma a volte visualizzare i gate della meccanica quantistica usando matrici e vettori può essere utile. Presentiamo quindi anche le forme matriciali/vettoriali dei gate/stati quantistici.

Gli stati che abbiamo già presentato sono scelti (in parte per convenzione e in parte per vincoli) in modo da avere forme vettoriali:

$$|0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix}$$ $$|1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}$$

In questo modo, uno stato arbitrario $|\psi\rangle = a|0\rangle+b|1\rangle$ può essere scritto come

$$|\psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}$$

C'è una certa scelta su come estendere la notazione agli stati a più qubit, ma la scelta seguente è abbastanza standard:

$$|00\rangle = \begin{pmatrix}1 \\ 0 \\ 0 \\ 0\end{pmatrix},|01\rangle = \begin{pmatrix}0 \\ 1 \\ 0 \\ 0\end{pmatrix}, |10\rangle = \begin{pmatrix}0 \\ 0 \\ 1 \\0\end{pmatrix},|11\rangle = \begin{pmatrix}0 \\ 0 \\ 0 \\ 1\end{pmatrix}.$$

Con questa scelta di notazione vettoriale in mente, possiamo introdurre i gate quantistici necessari, i loro effetti sugli stati quantistici e le loro forme matriciali.

Gate H di Hadamard: Crea uno stato di sovrapposizione. gate a qubit singolo.

$$H|0\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right),$$ $$H|1\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right)$$ $$H=\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}$$

Un circuito con un gate Hadamard si costruisce come segue:

from qiskit import QuantumCircuit

qc = QuantumCircuit(1)
qc.h(0)
qc.draw("mpl")

Gate CNOT Controlled-NOT: Questo gate utilizza due qubit: un controllo e un bersaglio (target). Controlla lo stato di un qubit di controllo che non viene modificato. Ma se il qubit di controllo è nello stato $|1\rangle$, il gate cambia lo stato del qubit bersaglio; se lo stato del qubit di controllo è $|0\rangle$ non viene apportata alcuna modifica. Nella notazione seguente, si assume che il qubit $A$ (il qubit più a destra) sia il controllo, e il qubit $B$ (il qubit più a sinistra) sia il bersaglio. Di seguito, la notazione utilizzata è $CNOT(q_{control},q_{target})|BA\rangle.$

$$CNOT(A,B)|00\rangle = |00\rangle, \\ CNOT(A,B)|01\rangle = |11\rangle, \\ CNOT(A,B)|10\rangle = |10\rangle, \\ CNOT(A,B)|11\rangle = |01\rangle$$

A volte si può vedere CNOT scritto con l'ordine di controllo e bersaglio semplicemente implicito. Ma non c'è tale ambiguità nel codice o nei diagrammi di circuito.

$$CNOT=\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}$$

Un gate CNOT appare un po' diverso in un circuito, poiché richiede due qubit. Ecco come viene implementato:

qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.draw("mpl")

Verifica la tua comprensione

Leggi la domanda seguente, rifletti sulla tua risposta, poi clicca il triangolo per rivelare la soluzione.

La maggior parte dei gate ha la stessa forma matriciale in Qiskit come ovunque altrove. Ma il gate CNOT agisce su due qubit, e quindi improvvisamente le convenzioni di ordinamento dei qubit diventano un problema. I testi che ordinano i qubit come $|q_0,q_1,...\rangle$ mostreranno una forma matriciale diversa per i loro gate CNOT. Verifica tramite moltiplicazione matriciale esplicita che la matrice CNOT sopra abbia l'azione corretta sullo stato $|01\rangle.$

Risposta:

$CNOT|01\rangle =\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}\begin{pmatrix}0 \\ 1 \\ 0 \\0\end{pmatrix} = \begin{pmatrix}0 \\ 0 \\ 0 \\1\end{pmatrix} = |11\rangle$

gate $X$: Equivalente a un'operazione NOT. gate a qubit singolo.

$$X|0\rangle = |1\rangle,\\X|1\rangle=|0\rangle$$ $$X=\begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}$$

In Qiskit, creare un circuito con un gate $X$ appare così:

qc = QuantumCircuit(1)
qc.x(0)
qc.draw("mpl")

gate $Z$: Aggiunge una "fase" a uno stato (un fattore prefisso che, nel caso degli autostati Z $|0\rangle$ e $|1\rangle$, vale rispettivamente 1 o -1). gate a qubit singolo.

$$Z|0\rangle = |0\rangle,\\Z|1\rangle=-|1\rangle$$ $$Z=\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}$$

In Qiskit, creare un circuito con un gate $Z$ appare così:

qc = QuantumCircuit(1)
qc.z(0)
qc.draw("mpl")

Teoria

Descriviamo il protocollo per il teletrasporto quantistico utilizzando la matematica. Poi, nella sezione successiva, realizzeremo questa configurazione usando un computer quantistico.

Alice e Bob fanno l'entanglement dei loro qubit: Inizialmente, il qubit di Alice e il qubit di Bob si trovano ciascuno, separatamente, nello stato $|0\rangle$ (una buona assunzione e anche l'inizializzazione corretta per i computer quantistici IBM®). Possiamo scrivere questo come $|0\rangle_B|0\rangle_A$ o semplicemente come $|00\rangle$. Calcoliamo cosa succede quando Alice e Bob applicano il gate Hadamard al qubit di Alice, e poi un gate CNOT con il qubit di Alice come controllo e quello di Bob come bersaglio:

$$\begin{aligned} CNOT(A,B)H_A |0\rangle_B|0\rangle_A &= CNOT(A,B)|0\rangle_B\frac{1}{\sqrt{2}}\left(|0\rangle_A+|1\rangle_A\right)\\ &=\frac{1}{\sqrt{2}}\left(CNOT(A,B)|0\rangle_B|0\rangle_A+CNOT(A,B)|0\rangle_B|1\rangle_A\right)\\ &=\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right) \end{aligned}$$

Nota che ora i qubit di Alice e Bob sono entangled. Sebbene non sia ancora determinato dalla natura se entrambi i loro qubit si trovino nello stato $|0\rangle$ o $|1\rangle$, è noto che i loro qubit si trovano nello stesso stato. Alice e Bob si separano: I due amici spostano i loro qubit in nuove posizioni, possibilmente molto distanti l'una dall'altra. Questo comporta molte avvertenze: non è banale spostare informazioni quantistiche senza disturbarle. Ma possono essere spostate, e in questo modulo lo farai tu stesso. Tieni però presente come avvertenza che ci aspettiamo di incontrare alcuni errori quando spostiamo le informazioni quantistiche molto.

Q viene introdotto: Lo stato segreto è preparato sul qubit Q:

$$|\psi\rangle_Q = \alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q$$

A questo punto Q è semplicemente adiacente al qubit di Alice (A). Non c'è stato alcun entanglement, quindi lo stato quantistico dei tre qubit insieme può essere scritto come:

$$|\psi\rangle_{AB}|\psi\rangle_Q = \frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right).$$

L'obiettivo è spostare le informazioni su Q dalla posizione di Alice alla posizione di Bob. A questo punto, non stiamo facendo alcuna affermazione o requisito sulla segretezza o sulla velocità del trasferimento di informazioni. Stiamo semplicemente esplorando come le informazioni possono spostarsi da Alice a Bob. Poiché le informazioni iniziano su Q, assumeremo che a Q sia assegnato il numero più basso tra i numeri di qubit, in modo tale che la notazione little-endian faccia sì che Q sia il qubit più a destra nella matematica seguente.

Alice fa l'entanglement dei qubit A e Q: Alice ora opera con un gate CNOT con il proprio qubit come controllo e Q come bersaglio, poi applica un gate Hadamard a Q. Calcoliamo lo stato a tre qubit dopo quell'operazione:

$$\begin{aligned} H_Q CNOT(A,Q)|\psi\rangle_{AB}|\psi\rangle_Q &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)\left(\alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q\right)\\ &= H_Q CNOT(A,Q)\frac{1}{\sqrt{2}}\left(\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|0\rangle_A|1\rangle_Q\right)+\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|1\rangle_A|1\rangle_Q\right)\right)\\ &= H_Q \frac{1}{\sqrt{2}}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q+\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right)\\ &= \frac{1}{2}\left(\alpha_0 |0\rangle_B|0\rangle_A|0\rangle_Q + \alpha_0 |0\rangle_B|0\rangle_A|1\rangle_Q + \alpha_1 |0\rangle_B|1\rangle_A|0\rangle_Q-\alpha_1 |0\rangle_B|1\rangle_A|1\rangle_Q\right)\\ &+\frac{1}{2}\left(\alpha_0 |1\rangle_B|1\rangle_A|0\rangle_Q + \alpha_0 |1\rangle_B|1\rangle_A|1\rangle_Q + \alpha_1 |1\rangle_B|0\rangle_A|0\rangle_Q - \alpha_1 |1\rangle_B|0\rangle_A|1\rangle_Q\right) \end{aligned}$$

Poiché A e Q si trovano nella stessa posizione, raggruppiamo i termini sopra in base ai risultati delle misurazioni sui qubit A e Q:

$$\begin{aligned} |\psi\rangle = \frac{1}{2}\left((\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|0\rangle_A|0\rangle_Q + (\alpha_0 |0\rangle_B-\alpha_1 |1\rangle_B)|0\rangle_A|1\rangle_Q + (\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|0\rangle_Q+ (-\alpha_1 |0\rangle_B+\alpha_0 |1\rangle_B)|1\rangle_A|1\rangle_Q \right)\\ \end{aligned}$$

Verifica la tua comprensione

Leggi la domanda seguente, rifletti sulla tua risposta, poi clicca il triangolo per rivelare la soluzione.

Data l'espressione sopra per gli stati di tutti e tre i qubit, qual è la probabilità che una misurazione dei qubit A e Q dia $|0\rangle_A|0\rangle_Q?$

Risposta:

25%. Per vederlo, ricorda che lo stato di Bob deve essere normalizzato, quindi $|_A \langle0|_Q\langle0| \frac{1}{2} |0\rangle_A|0\rangle_Q (\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}|(\alpha_0 |0\rangle_B+\alpha_1 |1\rangle_B)|^2 = \frac{1}{4}$

Ora Alice può misurare i qubit A e Q. Non può controllare il risultato di quella misurazione, poiché le misurazioni quantistiche sono probabilistiche. Quindi quando misura, ci sono 4 possibili risultati e tutti e 4 sono ugualmente probabili: $|0\rangle_A|0\rangle_Q,$ $|0\rangle_A|1\rangle_Q,$ $|1\rangle_A|0\rangle_Q,$ e $|1\rangle_A|1\rangle_Q.$ Nota che ogni risultato ha implicazioni diverse per il qubit di Bob. Ad esempio, se Alice trova i suoi qubit in $|0\rangle_A|0\rangle_Q,$ questo ha collassato l'intero stato quantistico a 3 qubit in $(\alpha_0|0\rangle_B+\alpha_1|1\rangle_B)|0\rangle_A|0\rangle_Q.$ Gli altri risultati di misurazione per Alice producono stati diversi per Bob. Questi sono raccolti nella tabella seguente.

Risultato di Alice	Stato di Bob	Istruzione a Bob	Risultato
$\vert 0\rangle_A \vert 0\rangle_Q$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$	Nessuna	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 0\rangle_A \vert 1\rangle_Q$	$\alpha_0\vert 0\rangle_B-\alpha_1\vert 1\rangle_B$	$Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 0\rangle_Q$	$\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
$\vert 1\rangle_A \vert 1\rangle_Q$	$-\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_B$	$X$ poi $Z$	$\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B$
Per tutti i possibili risultati di misurazione sui qubit di Alice, il qubit di Bob è lasciato in uno stato vagamente simile allo stato segreto originariamente su Q. Nel caso in cui Alice misuri $	0\rangle_C	0\rangle_A$(la prima riga della tabella), il qubit di Bob è lasciato esattamente nello stato segreto! Negli altri casi, c'è qualcosa di sbagliato nello stato. I coefficienti ($\alpha$) sono invertiti, o c'è un segno "-" dove dovrebbe esserci un "+", o entrambe le cose. Per modificare il qubit di Bob in modo da renderlo esattamente uguale allo stato segreto, Alice deve chiamare Bob (usare qualche mezzo di comunicazione classica) e dire a Bob di eseguire operazioni aggiuntive sul suo qubit, come indicato nella tabella. Ad esempio, nella terza riga i coefficienti sono invertiti. Se Alice chiama Bob e gli dice di applicare un gate$X$al suo qubit, questo trasforma un$	0\rangle$in un$

Ora dovrebbe essere chiaro perché non possiamo usare questa configurazione per inviare informazioni più velocemente della luce. Potremmo essere fortunati e misurare $|0\rangle_A|0\rangle_Q,$ il che significa che Bob ha esattamente lo stato segreto, istantaneamente. Ma Bob non lo sa finché non lo chiamiamo e gli diciamo "Abbiamo misurato $|0\rangle_A|0\rangle_Q$, quindi non devi fare nulla."

Nel pensiero sperimentale, i qubit sono spesso fisicamente separati e portati in una nuova posizione. I computer quantistici IBM® utilizzano qubit allo stato solido su un chip che non possono essere separati. Quindi, invece di spostare Alice e Bob in posizioni diverse, separeremo le informazioni sul chip stesso utilizzando i cosiddetti "swap gate" per spostare le informazioni da un qubit a un altro.

Esperimento 1: Teletrasporto di base

IBM Quantum consiglia di affrontare i problemi di quantum computing usando un framework che chiamiamo "Qiskit patterns". Consiste nei seguenti passi.

• Passo 1: Mappa il tuo problema su un circuito quantistico
• Passo 2: Ottimizza il tuo circuito per l'esecuzione su hardware quantistico reale
• Passo 3: Esegui il tuo job sui computer quantistici IBM usando le Runtime Primitives
• Passo 4: Post-elabora i risultati

Passo 1: Mappa il tuo problema su un circuito quantistico

Tutta la matematica che abbiamo fatto sopra delineava il passo 1. Lo implementeremo ora, costruendo il nostro circuito quantistico con Qiskit! Iniziamo creando un circuito quantistico con tre qubit e intreccando i due qubit di Alice e Bob. Prenderemo questi come qubit 1 e 2, e riserveremo il qubit 0 per lo stato segreto.

# Step 1: Map your problem to a quantum circuit

# Import some general packages
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np

# Define registers
secret = QuantumRegister(1, "Q")
Alice = QuantumRegister(1, "A")
Bob = QuantumRegister(1, "B")

cr = ClassicalRegister(3, "c")

qc = QuantumCircuit(secret, Alice, Bob, cr)

# We entangle Alice's and Bob's qubits as in our work above. We apply a Hadamard gate and then a CNOT gate.
# Note that the second argument in the CNOT gate is the target.
qc.h(Alice)
qc.cx(Alice, Bob)

# Inserting a barrier changes nothing about the logic. It just allows us to force gates to be positioned in "layers".
qc.barrier()

# Now we will use random variables to create the secret state. Don't worry about the "u" gate and the details.
np.random.seed(42)  # fixing seed for repeatability
theta = np.random.uniform(0.0, 1.0) * np.pi  # from 0 to pi
varphi = np.random.uniform(0.0, 2.0) * np.pi  # from 0 to 2*pi

# Assign the secret state to the qubit on the other side of Alice's (qubit 0), labeled Q
qc.u(theta, varphi, 0.0, secret)
qc.barrier()

# Now entangle Q and Alice's qubits as in the discussion above.
qc.cx(secret, Alice)
qc.h(secret)
qc.barrier()

# Now Alice measures her qubits, and stores the outcomes in the "classical registers" cr[]
qc.measure(Alice, cr[1])
qc.measure(secret, cr[0])

# Now we insert some conditional logic. If Alice measures Q in a "1" we need a Z gate, and if Alice measures A in a "1" we need an X gate (see the table).
with qc.if_test((cr[1], 1)):
    qc.x(Bob)
with qc.if_test((cr[0], 1)):
    qc.z(Bob)

qc.draw(output="mpl")

È tutto ciò che dobbiamo fare per teletrasportare lo stato di Alice verso Bob. Tuttavia, ricorda che quando misuriamo uno stato quantistico $\alpha_0 |0\rangle+\alpha_1|1\rangle$ troviamo o $|0\rangle$ o $|1\rangle.$ Quindi alla fine di tutto questo, Bob ha sicuramente lo stato segreto di Alice, ma non possiamo facilmente verificarlo con una misurazione. Affinché una misurazione ci dica che abbiamo fatto questo correttamente, dobbiamo usare un trucco. Avevamo un operatore etichettato "U" per "unitario" che abbiamo usato per preparare lo stato segreto di Alice. Possiamo applicare l'inverso di U alla fine del nostro circuito. Se U ha mappato lo stato $|0\rangle$ di Alice in $\alpha_0 |0\rangle+\alpha_1|1\rangle$, allora l'inverso di U mapperà $\alpha_0 |0\rangle+\alpha_1|1\rangle$ di Bob di nuovo su $|0\rangle.$ Quindi questa ultima parte non verrebbe necessariamente eseguita se l'obiettivo fosse solo spostare informazioni quantistiche. Viene fatta solo per verificare noi stessi.

# Add the inverse of U and measure Bob's qubit.
qc.barrier()

qc.u(theta, varphi, 0.0, Bob).inverse()  # inverse of u(theta,varphi,0.0)
qc.measure(Bob, cr[2])  # add measurement gate

qc.draw(output="mpl")

Quindi se abbiamo fatto questo correttamente, la nostra misurazione sul qubit di Bob dovrebbe produrre uno stato $|0\rangle$. Naturalmente, queste misurazioni sono probabilistiche. Quindi anche se c'è anche solo una piccola possibilità di misurare il qubit di Bob nello stato $|1\rangle$, una singola misurazione potrebbe risultare $|1\rangle.$ Vorremmo davvero fare molte misurazioni per essere certi che la probabilità di $|0\rangle$ sia abbastanza alta.

Passo 2: Ottimizza il problema per l'esecuzione quantistica

Questo passo prende le operazioni che vogliamo eseguire e le esprime in termini delle funzionalità di un computer quantistico specifico. Mappa anche il nostro problema sul layout del computer quantistico.

Inizieremo caricando diversi pacchetti necessari per comunicare con i computer quantistici IBM. Dobbiamo anche selezionare un backend su cui eseguire. Possiamo scegliere il backend meno occupato, oppure selezionare un backend specifico di cui conosciamo le proprietà.

C'è del codice di seguito per salvare le tue credenziali al primo utilizzo. Assicurati di eliminare queste informazioni dal notebook dopo averle salvate nel tuo ambiente, in modo che le tue credenziali non vengano condivise accidentalmente quando condividi il notebook. Consulta Configura il tuo account IBM Cloud e Inizializza il servizio in un ambiente non attendibile per ulteriori indicazioni.

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load the Qiskit Runtime service

# Syntax for first saving your token.  Delete these lines after saving your credentials.
# QiskitRuntimeService.save_account(channel='ibm_quantum_platform', instance = '<YOUR_IBM_INSTANCE_CRN>', token='<YOUR-API_KEY>', overwrite=True, set_as_default=True)
# service = QiskitRuntimeService(channel='ibm_quantum_platform')

# Load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_brisbane".
backend = service.least_busy(operational=True, simulator=False, min_num_qubits=127)
# backend = service.backend("ibm_brisbane")
print(backend.name)

ibm_sherbrooke

Abilitiamo esplicitamente la logica sulle misurazioni.

from qiskit.circuit import IfElseOp

backend.target.add_instruction(IfElseOp, name="if_else")

Ora dobbiamo "transpilare" il circuito quantistico. Questo comporta molti sotto-passi ed è un argomento affascinante. Solo per dare un esempio di un sotto-passo: non tutti i computer quantistici possono implementare direttamente tutti i gate logici in Qiskit. Dobbiamo scrivere i gate del nostro circuito in termini di gate che il computer quantistico può implementare. Possiamo effettuare quel processo, e altri, usando un preset pass manager. Impostare optimization = 3 (il livello di ottimizzazione più alto) garantisce che la mappatura dal nostro circuito quantistico astratto alle istruzioni date al computer quantistico sia efficiente quanto la nostra pre-elaborazione può renderla.

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

Un "Sampler" è una primitiva progettata per campionare i possibili stati risultanti da un circuito quantistico e raccogliere statistiche su quali stati potrebbero essere misurati e con quale probabilità. Importiamo qui il Qiskit Runtime Sampler:

# Load the Runtime primitive and session
from qiskit_ibm_runtime import SamplerV2 as Sampler

sampler = Sampler(mode=backend)

Non tutti i calcoli su un computer quantistico possono essere ragionevolmente simulati su computer classici. Questo semplice teletrasporto sicuramente può esserlo, ma non sorprende affatto che possiamo salvare classicamente le informazioni in un posto o in un altro. Raccomandiamo vivamente di eseguire questi calcoli usando un vero computer quantistico IBM. Ma nel caso tu abbia esaurito l'utilizzo mensile gratuito, o se qualcosa deve essere completato in classe e non può aspettare in coda, questo modulo può essere completato usando un simulatore. Per farlo, esegui semplicemente la cella sottostante e decommenta le righe associate nei passi "Execute".

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

# Load the Aer simulator and generate a noise model based on the currently-selected backend.
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel

noise_model = NoiseModel.from_backend(backend)

# Define a simulator using Aer, and use it in Sampler.
backend_sim = AerSimulator(noise_model=noise_model)
sampler_sim = BackendSamplerV2(backend=backend_sim)

# Alternatively, load a fake backend with generic properties and define a simulator.
# backend_gen = GenericBackendV2(num_qubits=18)
# sampler_gen = BackendSamplerV2(backend=backend_gen)

Passo 3: Esegui

Usa il sampler per eseguire il tuo job, con il circuito come argomento.

job = sampler.run([qc_isa])
# job = sampler_sim.run([qc_isa])
res = job.result()
counts = res[0].data.c.get_counts()

Passo 4: Post-elaborazione e analisi

Tracciamo i risultati e interpretiamoli.

# This required 5 s to run on a Heron r2 processor on 10-28-24
from qiskit.visualization import plot_histogram

plot_histogram(counts)

Verifica la tua comprensione

Leggi la domanda qui sotto, pensa alla tua risposta, poi clicca sul triangolo per rivelare la soluzione.

Quali degli stati sopra indicano un teletrasporto riuscito e come puoi dirlo?

Risposta:

Gli stati $|000\rangle,$ $|001\rangle,$ $|010\rangle,$ $|011\rangle$ sono tutti compatibili con un teletrasporto riuscito. Questo perché abbiamo aggiunto un gate per annullare la preparazione iniziale dello stato segreto. Se lo stato segreto è stato teletrasportato con successo al qubit di Bob, quel gate aggiuntivo dovrebbe riportare il qubit di Bob allo stato $|0\rangle$. Quindi qualsiasi stato sopra con il qubit di Bob (qubit 0, misurato anche nella componente 0 del registro classico, e quindi il più alto/più a destra) nello stato $|0\rangle$ indica successo.

Questo grafico mostra tutti i risultati delle misurazioni per i tre qubit, su 5.000 prove o "shots". Abbiamo sottolineato in precedenza che Alice misurerà tutti i possibili stati per i qubit A e Q con uguale probabilità. Abbiamo assegnato i qubit 0-2 nel circuito rispettivamente a Q, A e B. Nella notazione little-endian, il qubit di Bob è il più a sinistra/più basso. Quindi le quattro barre a sinistra corrispondono al qubit di Bob in $|0\rangle$, e gli altri due qubit sono in tutte le combinazioni possibili con probabilità approssimativamente uguale. Nota che quasi tutte (di solito ~95%) le misurazioni producono il qubit di Bob nello stato $|0\rangle$, il che significa che la nostra configurazione ha avuto successo! Ci sono un manciata di shots (~5%) che hanno prodotto il qubit di Bob nello stato $|1\rangle$. Questo non dovrebbe essere logicamente possibile. Tuttavia, tutti i moderni computer quantistici soffrono di rumore ed errori in misura molto maggiore rispetto ai computer classici. E la correzione degli errori quantistici è ancora un campo emergente.

Esperimento 2: Teletrasporto attraverso un processore

Probabilmente, la parte più interessante del teletrasporto quantistico è che uno stato quantistico può essere teletrasportato su lunghe distanze istantaneamente (sebbene la comunicazione classica di gate aggiuntivi non sia istantanea). Come già detto, non possiamo staccare i qubit dal processore e spostarli in giro. Ma possiamo spostare le informazioni da un qubit all'altro, finché i qubit coinvolti nel teletrasporto si trovano sui lati opposti del processore. Ripetiamo i passi che abbiamo eseguito sopra, ma ora costruiremo un circuito più grande con abbastanza qubit da attraversare il processore.

Passo 1: Mappa il tuo problema su un circuito quantistico

Questa volta, i qubit corrispondenti ad Alice e Bob cambieranno. Quindi non denomineremo un singolo qubit "A" e un altro "B". Piuttosto, numereremo i qubit e useremo variabili per rappresentare la posizione attuale delle informazioni sui qubit appartenenti ad Alice e Bob. Tutti gli altri passi tranne i gate swap sono come descritti in precedenza.

# Step 1: Map

# Define registers
qr = QuantumRegister(13, "q")

qc = QuantumCircuit(qr, cr)

# Define registers
secret = QuantumRegister(1, "Q")
ebitsa = QuantumRegister(6, "A")
ebitsb = QuantumRegister(6, "B")
# q = ClassicalRegister(1, "q meas")
# a = ClassicalRegister(1, "a")
# b = ClassicalRegister(1, "b")
cr = ClassicalRegister(3, "c")
qc = QuantumCircuit(secret, ebitsa, ebitsb, cr)

# We'll start Alice in the middle of the circuit, then move information outward in both directions.
Alice = 5
Bob = 0
qc.h(ebitsa[Alice])
qc.cx(ebitsa[Alice], ebitsb[Bob])

# Starting with Bob and Alice in the center, we swap their information onto adjacent qubits, until the information is on distant qubits.

for n in range(Alice):
    qc.swap(ebitsb[Bob], ebitsb[Bob + 1])
    qc.swap(ebitsa[Alice], ebitsa[Alice - 1])
    Alice = Alice - 1
    Bob = Bob + 1

qc.barrier()

# Create a random state for Alice (qubit zero)
np.random.seed(42)  # fixing seed for repeatability
# theta = np.random.uniform(0.0, 1.0) * np.pi    #from 0 to pi
theta = 0.3
varphi = np.random.uniform(0.0, 2.0) * np.pi  # from 0 to 2*pi

qc.u(theta, varphi, 0.0, secret)

# Entangle Alice's two qubits
qc.cx(secret, ebitsa[Alice])
qc.h(secret)

qc.barrier()

# Make measurements of Alice's qubits and store the results in the classical register.
qc.measure(ebitsa[Alice], cr[1])
qc.measure(secret, cr[0])

# Send instructions to Bob's qubits based on the outcome of Alice's measurements.
with qc.if_test((cr[1], 1)):
    qc.x(ebitsb[Bob])
with qc.if_test((cr[0], 1)):
    qc.z(ebitsb[Bob])

qc.barrier()

# Invert the preparation we did for Carl's qubit so we can check whether we did this correctly.
qc.u(theta, varphi, 0.0, ebitsb[Bob]).inverse()  # inverse of u(theta,varphi,0.0)
qc.measure(ebitsb[Bob], cr[2])  # add measurement gate

qc.draw("mpl")

Puoi vedere nel diagramma del circuito che i passi logici sono gli stessi. L'unica differenza è che abbiamo usato i gate swap per portare lo stato del qubit di Alice dal qubit 6 ($A_5$) al qubit 1 ($A_0$), proprio accanto a Q. E abbiamo usato gate swap per portare lo stato iniziale di Bob dal qubit 7 ($B_0$) al qubit 12 ($B_5$). Nota che lo stato sul qubit 12 non è nemmeno correlato allo stato segreto di Q finché non vengono effettuate misurazioni sui qubit distanti 0 e 1, e lo stato sul qubit 12 non è uguale allo stato segreto finché non vengono applicati i gate condizionali $X$ e $Z$.

Passo 2: Ottimizza il tuo circuito

Normalmente, quando usiamo il pass manager per transpilare e ottimizzare i nostri circuiti, ha senso impostare optimization_level = 3, perché vogliamo che i nostri circuiti siano il più efficienti possibile. In questo caso, non c'è alcuna ragione computazionale per noi di trasferire gli stati dai qubit 6 e 7 ai qubit 1 e 12. Quello era solo qualcosa che abbiamo fatto per dimostrare il teletrasporto su una distanza. Se chiediamo al pass manager di ottimizzare il nostro circuito, si renderà conto che non c'è alcuna ragione logica per questi gate swap, li rimuoverà ed eseguirà le operazioni sui gate su qubit adiacenti. Quindi per questo caso speciale, usiamo optimization_level = 0.

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pmzero = generate_preset_pass_manager(target=target, optimization_level=0)

qc_isa_zero = pmzero.run(qc)

print(qc_isa_zero.depth())

105

Possiamo visualizzare dove si trovano questi qubit nel processore quantistico usando la funzione plot_circuit_layout.

Passo 3: Esegui

Come prima, raccomandiamo di eseguire su veri computer quantistici IBM. Se il tuo utilizzo mensile gratuito è stato raggiunto, sentiti libero di decommentare le celle del simulatore per eseguire su un simulatore.

# This required 5 s to run on a Heron r2 processor on 10-28-24
job = sampler.run([qc_isa_zero])
# job = sampler_sim.run([qc_isa_zero])
counts = job.result()[0].data.c.get_counts()

from qiskit.visualization import plot_histogram

plot_histogram(counts)

Passo 4: Post-elaborazione classica

Vediamo di nuovo che le probabilità per i possibili risultati per i qubit di Alice sono abbastanza uniformi. C'è una forte preferenza per trovare il qubit di Bob in $|0\rangle$ dopo aver invertito il codice segreto, il che significa che c'è un'alta probabilità che abbiamo correttamente teletrasportato lo stato segreto attraverso il processore da Q a Bob (qubit da 0 a 12). Tuttavia, notiamo che ora c'è circa una probabilità più alta di non misurare $|0\rangle$ per Bob. Questa è una lezione importante nel quantum computing: più gate aggiungi in sequenza, specialmente gate multi-qubit come i gate swap, più rumore ed errori incontrerai.

Domande

Gli istruttori possono richiedere versioni di questi notebook con chiavi di risposta e indicazioni sul posizionamento nei curricula comuni compilando questo breve sondaggio su come vengono utilizzati i notebook.

Concetti fondamentali

• I qubit possono essere intrecciati, il che significa che una misurazione di un qubit influisce o addirittura determina lo stato di un altro qubit.
• L'entanglement differisce dalle correlazioni classiche; per esempio, i qubit A e B potrebbero trovarsi in una sovrapposizione di stati come $\alpha_0|00\rangle+\alpha_1|11\rangle.$ Lo stato di A o B potrebbe essere indeterminato per natura, eppure A e B potrebbero comunque essere garantiti di trovarsi nello stesso stato.
• Attraverso una combinazione di entanglement e misurazioni, possiamo trasferire uno stato (che può memorizzare informazioni) da un qubit a un altro. Questo trasferimento può anche essere eseguito su lunghe distanze, e questo viene chiamato teletrasporto quantistico.
• Il teletrasporto quantistico si basa su misurazioni quantistiche, che sono probabilistiche. Pertanto, la comunicazione classica può essere necessaria per perfezionare gli stati teletrasportati. Questo impedisce al teletrasporto quantistico di spostare informazioni più veloce della luce. Il teletrasporto quantistico non viola la relatività o la causalità.
• I moderni computer quantistici sono più suscettibili al rumore e agli errori rispetto ai computer classici. Aspettati qualche percentuale di errore.
• Più gate aggiungi in sequenza (specialmente gate a 2 qubit) più errori e rumore puoi aspettarti.

Domande Vero/Falso

1. V/F Il teletrasporto quantistico può essere utilizzato per inviare informazioni più veloce della luce.
2. V/F Le prove moderne suggeriscono che il collasso di uno stato quantistico si propaga più velocemente della luce.
3. V/F In Qiskit, i qubit sono ordinati negli stati con il qubit con il numero più basso a destra, come in $|q_3,q_2,q_1, q_0\rangle$

Domande a scelta multipla

1. I qubit A e B sono intrecciati, poi separati da una grande distanza $d$. Il qubit A viene misurato. Quale affermazione è corretta riguardo alla velocità con cui lo stato del qubit B viene influenzato?

• a. Il qubit B viene influenzato istantaneamente, entro la tolleranza sperimentale, negli esperimenti condotti finora.
• b. Il qubit B viene influenzato dopo un tempo $d/c$, il che significa che lo stato quantistico "collassa" approssimativamente alla velocità della luce, entro la tolleranza sperimentale.
• c. Il qubit B viene influenzato solo dopo che è avvenuta la comunicazione classica, il che significa che accade in un tempo superiore a $d/c$.
• d. Nessuna delle precedenti

2. Ricorda che la probabilità di misurazione è correlata alle ampiezze negli stati quantistici. Per esempio, se un qubit è inizialmente nello stato $\alpha_0|0\rangle+\alpha_1 |1\rangle,$ la probabilità di misurare lo stato $|0\rangle$ è $|\alpha_0|^2.$ Non tutte le serie di misurazioni corrisponderanno esattamente a queste probabilità, a causa del campionamento finito (proprio come lanciare una moneta potrebbe dare testa due volte di seguito). L'istogramma delle misurazioni sottostante potrebbe corrispondere a quale dei seguenti stati quantistici? Seleziona la migliore opzione.

• a. $|0\rangle$
• b. $\frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right)$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)$
• d. $\frac{4}{5}|0\rangle+\frac{3}{5}|1\rangle$
• e. $\frac{3}{5}|0\rangle+\frac{4}{5}|1\rangle$

3. Quale dei seguenti stati mostra i qubit A e B intrecciati? Seleziona tutti quelli che si applicano.

• a. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)$
• b. $\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)$
• d. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|0\rangle_A\right)$
• e. $|0\rangle_B|0\rangle_A$

4. In questo modulo, abbiamo preparato uno stato intrecciato: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right).$ Ma ci sono molti altri stati intrecciati che si potrebbero usare per un protocollo simile. Quale degli stati sottostanti potrebbe produrre un istogramma di misurazione a 2 qubit come il seguente? Seleziona la migliore risposta.

• a. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)$
• b. $\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A$
• c. $\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)$
• d. $\frac{4}{5}|0\rangle_B|1\rangle_A+\frac{3}{5}|1\rangle_B|0\rangle_A$
• e. $|0\rangle_B|0\rangle_A$

Domande di discussione

1. Descrivi il protocollo di teletrasporto quantistico, dall'inizio alla fine, al tuo partner/gruppo. Vedi se hanno qualcosa da aggiungere, o se hanno domande.

2. C'è qualcosa di unico nello stato iniziale intrecciato tra Alice e Bob: $\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)?$ Se sì, cosa c'è di unico? Se no, quali altri stati intrecciati avremmo potuto usare?