Sari la conținutul principal

Teleportare cuantică

Pentru acest modul Qiskit in Classrooms, studenții trebuie să aibă un mediu Python funcțional cu următoarele pachete instalate:

  • qiskit v2.1.0 sau mai nou
  • qiskit-ibm-runtime v0.40.1 sau mai nou
  • qiskit-aer v0.17.0 sau mai nou
  • qiskit.visualization
  • numpy
  • pylatexenc

Pentru a configura și instala pachetele de mai sus, consultă ghidul Instalează Qiskit. Pentru a rula joburi pe calculatoare cuantice reale, studenții vor trebui să își creeze un cont IBM Quantum® urmând pașii din ghidul Configurează-ți contul IBM Cloud.

Acest modul a fost testat și a utilizat 14 secunde de timp QPU. Aceasta este doar o estimare. Utilizarea ta reală poate varia.

# 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'

Urmărește prezentarea modulului realizată de Dr. Katie McCormick mai jos sau apasă aici pentru a o viziona pe YouTube.

Introducere și context​

Teleportarea cuantică este o tehnică din fizica cuantică ce permite transferul informației cuantice dintr-o locație în alta fără a deplasa fizic particulele. Spre deosebire de conceptul de teleportare din science-fiction, acest proces nu implică transportul materiei. În schimb, se bazează pe principiul entanglementului cuantic, prin care două particule devin legate indiferent de distanță. Printr-o serie de măsurători precise și comunicare clasică, starea cuantică a unei particule poate fi recreată într-o altă particulă aflată la distanță, „teleportând" efectiv informația cuantică. În acest modul, vom vedea cum funcționează acest lucru din punct de vedere matematic, iar apoi vom implementa teleportarea cuantică pe un calculator cuantic real. Introducerea de față va fi scurtă; pentru mai mult context despre informația cuantică și explicații suplimentare despre teleportare, îți recomandăm cursul lui John Watrous despre Bazele informației cuantice, și în special secțiunea despre Teleportare.

Biții clasici pot fi în stările 0 sau 1. Biții cuantici (qubiții) pot fi în stări cuantice notate ∣0⟩|0\rangle și ∣1⟩|1\rangle, dar și combinații liniare ale acestor stări, numite „superpozitii", de forma ∣ψ⟩=α0∣0⟩+α1∣1⟩|\psi\rangle = \alpha_0|0\rangle +\alpha_1|1\rangle, cu α0,α1∈C,\alpha_0,\alpha_1 \in \mathbb{C}, și ∣α0∣2+∣α1∣2=1.|\alpha_0|^2+|\alpha_1|^2 = 1. Deși stările pot exista în această superpozitie, o măsurătoare a stării o va „colaps a" fie în ∣0⟩|0\rangle, fie în ∣1⟩|1\rangle. Parametrii aa și bb sunt legați de probabilitatea fiecărui rezultat al măsurătorii conform

P0=∣α0∣2P_0 = |\alpha_0|^2 P1=∣α1∣2P_1 = |\alpha_1|^2

De unde și constrângerea că ∣α0∣2+∣α1∣2=1.|\alpha_0|^2+|\alpha_1|^2 = 1.

O altă caracteristică esențială este că qubiții pot fi „entanglați", ceea ce înseamnă că măsurătoarea unui qubit poate influența rezultatul măsurătorii unui alt qubit entanglat. A înțelege în ce fel entanglementul diferă de simplele corelații clasice este ceva mai dificil. Să explicăm mai întâi notația noastră. Considerăm doi qubiți aparținând prietenei 0 (Alice) și prietenului 1 (Bob), fiecare în starea ∣0⟩|0\rangle

∣0⟩B∣0⟩A|0\rangle_B|0\rangle_A

sau

∣0⟩1∣0⟩0|0\rangle_1|0\rangle_0

uneori prescurtat simplu ca

∣00⟩|00\rangle

Observă că Qubit-ul cu numărul (sau litera) cel mai mic se află cel mai la dreapta. Aceasta este o convenție numită notație „little-endian", folosită în tot Qiskit. Dacă starea cu doi qubiți a celor doi prieteni este ∣00⟩|00\rangle și aceștia măsoară starea qubiților lor respectivi, fiecare va găsi un 0. Similar, dacă qubiții ar fi în starea ∣11⟩|11\rangle, fiecare dintre măsurătorile lor ar produce un 1. Acest lucru nu diferă de cazul clasic. Totuși, în calculul cuantic, putem combina aceasta cu superpozitia pentru a obține stări de forma

12(∣00⟩+∣11⟩)\frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)

Într-o stare ca aceasta, dacă qubiții lui Alice și Bob sunt în starea 0 sau 1 nu se știe încă, ba chiar nu este determinat de natură, și totuși știm că vor măsura aceeași stare pentru qubit-ul lor. De exemplu, dacă Bob măsoară qubit-ul său și obține starea ∣0⟩|0\rangle, singurul mod în care se poate întâmpla asta este dacă măsurătoarea a colaps at starea cu doi qubiți la una din cele două stări posibile, anume la ∣00⟩|00\rangle. Aceasta lasă qubit-ul lui Alice tot în starea ∣0⟩|0\rangle.

Entanglementul qubiților în acest fel nu impune ca qubiții să rămână fizic aproape unul de celălalt. Cu alte cuvinte, am putea entangla qubiți, apoi să îi separăm la o distanță mare, și să folosim entanglementul lor pentru a transmite informații. O stare entanglată ca cea de mai sus este o unitate de bază a entanglementului și este uneori numită „e-bit" — un singur bit de entanglement. Acești e-biți pot fi gândiți ca resurse în comunicarea cuantică, deoarece fiecare e-bit partajat între parteneri aflați la distanță poate fi utilizat, așa cum schițăm aici, pentru a muta informația dintr-o locație în alta.

Primul gând al multor persoane care aud despre asta pentru prima dată se referă la încălcarea relativității: putem folosi asta pentru a transmite informații mai repede decât lumina? Nu ezita să chestionezi și să explorezi regulile științifice, dar din păcate asta nu ne va permite să trimitem informații mai repede decât lumina, din motive care vor deveni clare pe parcursul acestui modul. Spoiler: uimitor, NU este din cauza vitezei cu care se propagă acest colaps, care pare să se întâmple mai repede decât lumina [1]. Pornim cu doi colaboratori, Alice și Bob, care se află inițial în același loc și pot lucra împreună pe aceiași qubiți. Acești colaboratori vor entangla qubiții lor. Apoi se vor separa în două locații geografice diferite, fiecare luând qubiții respectivi cu ei. Alice va obține apoi informație cuantică pe un nou Qubit Q. Nu facem nicio presupunere despre informația de pe Q. Starea lui Q ar putea fi un secret necunoscut lui Alice; ar putea fi necunoscut tuturor. Dar Alice primește sarcina de a transfera informația de pe Q lui Bob. Ea va face asta folosind teleportarea cuantică.

Pentru a realiza acest lucru, va trebui să cunoaștem câteva operații cuantice sau „gate-uri".

Operatori cuantici (gate-uri)​

Poți sări peste această secțiune dacă ești deja familiar cu gate-urile cuantice. Dacă vrei să înțelegi mai bine aceste gate-uri, consultă Bazele informației cuantice, în special primele două lecții, pe IBM Quantum Learning.

Pentru acest protocol de teleportare vom folosi în principal două tipuri de gate-uri cuantice: gate-ul Hadamard și gate-ul CNOT. Câteva altele vor juca un rol mai mic: gate-ul XX, gate-ul ZZ și gate-ul SWAP.

Acest modul poate fi parcurs cu cunoștințe de algebră liniară foarte limitate, dar uneori vizualizarea gate-urilor mecanicii cuantice cu ajutorul matricelor și vectorilor poate fi utilă. Prin urmare, prezentăm aici formele matriceale/vectoriale ale gate-urilor/stărilor cuantice.

Stările pe care le-am prezentat deja sunt alese (parțial prin convenție și parțial prin constrângeri) să aibă forme vectoriale:

∣0⟩=(10)|0\rangle = \begin{pmatrix}1 \\ 0\end{pmatrix} ∣1⟩=(01)|1\rangle = \begin{pmatrix}0 \\ 1\end{pmatrix}

În acest fel, o stare arbitrară ∣ψ⟩=a∣0⟩+b∣1⟩|\psi\rangle = a|0\rangle+b|1\rangle poate fi scrisă ca

∣ψ⟩=(ab)|\psi\rangle =\begin{pmatrix}a \\ b\end{pmatrix}

Există o anumită libertate în modul de extindere a notației la stări cu mai mulți qubiți, dar alegerea de mai jos este destul de standard:

∣00⟩=(1000),∣01⟩=(0100),∣10⟩=(0010),∣11⟩=(0001).|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}.

Având în minte această alegere a notației vectoriale, putem introduce gate-urile cuantice de care avem nevoie, efectele lor asupra stărilor cuantice și formele lor matriceale.

Gate-ul H Hadamard: Creează o stare de superpozitie. Gate cu un singur Qubit.

H∣0⟩=12(∣0⟩+∣1⟩),H|0\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right), H∣1⟩=12(∣0⟩−∣1⟩)H|1\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right) H=12(111−1)H=\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix}

Un Circuit cu un gate Hadamard se construiește astfel:

from qiskit import QuantumCircuit

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

Output of the previous code cell

Gate-ul CNOT Controlled-NOT: Acest gate folosește doi qubiți: un control și o țintă. Verifică starea unui qubit de control, care nu se modifică. Dar dacă qubit-ul de control este în starea ∣1⟩|1\rangle, gate-ul schimbă starea qubit-ului țintă; dacă starea qubit-ului de control este ∣0⟩|0\rangle, nu se face nicio modificare. În notația de mai jos, presupunem că qubit-ul AA (cel mai din dreapta) este controlul, iar qubit-ul BB (cel mai din stânga) este ținta. Mai jos, notația folosită este CNOT(qcontrol,qtarget)∣BA⟩.CNOT(q_{control},q_{target})|BA\rangle.

CNOT(A,B)∣00⟩=∣00⟩,CNOT(A,B)∣01⟩=∣11⟩,CNOT(A,B)∣10⟩=∣10⟩,CNOT(A,B)∣11⟩=∣01⟩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

Uneori poți vedea CNOT scris cu ordinea controlului și a țintei pur și simplu implicită. Dar nu există o astfel de ambiguitate în cod sau în diagramele de Circuit.

CNOT=(1000000100100100)CNOT=\begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0\end{pmatrix}

Un gate CNOT arată puțin diferit într-un Circuit, deoarece necesită doi qubiți. Iată cum se implementează:

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

Output of the previous code cell

Verifică-ți înțelegerea​

Citește întrebarea de mai jos, gândește-te la răspuns, apoi apasă triunghiul pentru a dezvălui soluția.

Majoritatea Gate-urilor au aceeași formă matriceală în Qiskit ca oriunde altundeva. Dar Gate-ul CNOT acționează pe două Qubit-uri, astfel că ordinea convențională a Qubit-urilor devine brusc o problemă. Textele care ordonează Qubit-urile ∣q0,q1,...⟩|q_0,q_1,...\rangle vor afișa o formă matriceală diferită pentru Gate-urile lor CNOT. Verifică prin înmulțire matriceală explicită că matricea CNOT de mai sus are acțiunea corectă asupra stării ∣01⟩.|01\rangle.

Răspuns:

CNOT∣01⟩=(1000000100100100)(0100)=(0001)=∣11⟩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-ul XX: Echivalent cu o operație NOT. Gate pe un singur Qubit.

X∣0⟩=∣1⟩,X∣1⟩=∣0⟩X|0\rangle = |1\rangle,\\X|1\rangle=|0\rangle X=(0110)X=\begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}

În Qiskit, crearea unui Circuit cu un Gate XX arată astfel:

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

Output of the previous code cell

Gate-ul ZZ: Adaugă o „fază" unei stări (un prefactor, care în cazul stărilor proprii Z ∣0⟩|0\rangle și ∣1⟩|1\rangle este fie 1, fie -1, respectiv). Gate pe un singur Qubit.

Z∣0⟩=∣0⟩,Z∣1⟩=−∣1⟩Z|0\rangle = |0\rangle,\\Z|1\rangle=-|1\rangle Z=(100−1)Z=\begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix}

În Qiskit, crearea unui Circuit cu un Gate ZZ arată astfel:

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

Output of the previous code cell

Teorie​

Să prezentăm protocolul pentru teleportarea cuantică folosind matematica. Apoi, în secțiunea următoare, vom realiza această configurație folosind un calculator cuantic.

Alice și Bob își împletesc Qubit-urile: Inițial, Qubit-ul lui Alice și Qubit-ul lui Bob se află fiecare, separat, în starea ∣0⟩|0\rangle (o presupunere rezonabilă și totodată inițializarea corectă pentru calculatoarele cuantice IBM®). Putem scrie aceasta ca ∣0⟩B∣0⟩A|0\rangle_B|0\rangle_A sau pur și simplu ca ∣00⟩|00\rangle. Să calculăm ce se întâmplă când Alice și Bob aplică Gate-ul Hadamard pe Qubit-ul lui Alice, iar apoi un Gate CNOT cu Qubit-ul lui Alice ca element de control și Qubit-ul lui Bob ca țintă:

CNOT(A,B)HA∣0⟩B∣0⟩A=CNOT(A,B)∣0⟩B12(∣0⟩A+∣1⟩A)=12(CNOT(A,B)∣0⟩B∣0⟩A+CNOT(A,B)∣0⟩B∣1⟩A)=12(∣0⟩B∣0⟩A+∣1⟩B∣1⟩A)\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}

Observă că acum Qubit-urile lui Alice și Bob sunt împletite. Deși natura nu a determinat încă dacă ambele Qubit-uri se află în starea ∣0⟩|0\rangle sau ∣1⟩|1\rangle, se știe că Qubit-urile lor sunt în aceeași stare. Alice și Bob se separă: Cei doi prieteni își mută Qubit-urile în locații noi, posibil foarte îndepărtate. Aceasta vine cu multe precauții: nu este trivial să muți informații cuantice fără a le perturba. Dar ele pot fi mutate și, într-adevăr, le vei muta în acest modul. Reține totuși că ne așteptăm să întâlnim unele erori atunci când mutăm informații cuantice de multe ori.

Q este introdus: Starea secretă este pregătită pe Qubit-ul Q:

∣ψ⟩Q=α0∣0⟩Q+α1∣1⟩Q|\psi\rangle_Q = \alpha_0 |0\rangle_Q + \alpha_1 |1\rangle_Q

În acest punct, Q este pur și simplu adiacent Qubit-ului lui Alice (A). Nu a existat nicio împletire, astfel că starea cuantică a celor trei Qubit-uri împreună poate fi scrisă ca:

∣ψ⟩AB∣ψ⟩Q=12(∣0⟩B∣0⟩A+∣1⟩B∣1⟩A)(α0∣0⟩Q+α1∣1⟩Q).|\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).

Scopul este de a muta informațiile de pe Q din locația lui Alice în locația lui Bob. În acest punct, nu facem nicio afirmație sau cerință privind secretul sau viteza transferului de informații. Explorăm pur și simplu cum poate circula informația de la Alice la Bob. Deoarece informațiile încep pe Q, vom presupune că Q primește cel mai mic număr dintre numerele Qubit-urilor, astfel încât notația little endian face ca Q să fie Qubit-ul cel mai din dreapta în matematica de mai jos.

Alice împletește Qubit-urile A și Q: Alice aplică acum un Gate CNOT cu propriul Qubit ca element de control și Q ca țintă, apoi aplică un Gate Hadamard pe Q. Să calculăm starea celor trei Qubit-uri după acea operație:

HQCNOT(A,Q)∣ψ⟩AB∣ψ⟩Q=HQCNOT(A,Q)12(∣0⟩B∣0⟩A+∣1⟩B∣1⟩A)(α0∣0⟩Q+α1∣1⟩Q)=HQCNOT(A,Q)12((α0∣0⟩B∣0⟩A∣0⟩Q+α1∣0⟩B∣0⟩A∣1⟩Q)+(α0∣1⟩B∣1⟩A∣0⟩Q+α1∣1⟩B∣1⟩A∣1⟩Q))=HQ12(α0∣0⟩B∣0⟩A∣0⟩Q+α1∣0⟩B∣1⟩A∣1⟩Q+α0∣1⟩B∣1⟩A∣0⟩Q+α1∣1⟩B∣0⟩A∣1⟩Q)=12(α0∣0⟩B∣0⟩A∣0⟩Q+α0∣0⟩B∣0⟩A∣1⟩Q+α1∣0⟩B∣1⟩A∣0⟩Q−α1∣0⟩B∣1⟩A∣1⟩Q)+12(α0∣1⟩B∣1⟩A∣0⟩Q+α0∣1⟩B∣1⟩A∣1⟩Q+α1∣1⟩B∣0⟩A∣0⟩Q−α1∣1⟩B∣0⟩A∣1⟩Q)\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}

Deoarece A și Q se află în aceeași locație, să grupăm termenii de mai sus în funcție de rezultatele măsurătorilor pe Qubit-urile A și Q:

∣ψ⟩=12((α0∣0⟩B+α1∣1⟩B)∣0⟩A∣0⟩Q+(α0∣0⟩B−α1∣1⟩B)∣0⟩A∣1⟩Q+(α1∣0⟩B+α0∣1⟩B)∣1⟩A∣0⟩Q+(−α1∣0⟩B+α0∣1⟩B)∣1⟩A∣1⟩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}

Verifică-ți înțelegerea​

Citește întrebarea de mai jos, gândește-te la răspuns, apoi apasă triunghiul pentru a dezvălui soluția.

Dat fiind expresia de mai sus pentru stările tuturor celor trei Qubit-uri, care este probabilitatea ca o măsurătoare a Qubit-urilor A și Q să producă ∣0⟩A∣0⟩Q?|0\rangle_A|0\rangle_Q?

Răspuns:

25%. Pentru a vedea aceasta, reamintește-ți că starea lui Bob trebuie să fie normalizată, deci ∣A⟨0∣Q⟨0∣12∣0⟩A∣0⟩Q(α0∣0⟩B+α1∣1⟩B)∣2=14∣(α0∣0⟩B+α1∣1⟩B)∣2=14 |_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}

Acum, Alice poate măsura Qubit-urile A și Q. Ea nu poate controla rezultatul acelei măsurători, deoarece măsurătorile cuantice sunt probabilistice. Astfel, când măsoară, există 4 rezultate posibile și toate 4 sunt la fel de probabile: ∣0⟩A∣0⟩Q,|0\rangle_A|0\rangle_Q, ∣0⟩A∣1⟩Q,|0\rangle_A|1\rangle_Q, ∣1⟩A∣0⟩Q|1\rangle_A|0\rangle_Q și ∣1⟩A∣1⟩Q.|1\rangle_A|1\rangle_Q. Observă că fiecare rezultat are implicații diferite pentru Qubit-ul lui Bob. De exemplu, dacă Alice constată că Qubit-urile ei se află în ∣0⟩A∣0⟩Q,|0\rangle_A|0\rangle_Q, aceasta a prăbușit întreaga stare cuantică de 3 Qubit-uri la (α0∣0⟩B+α1∣1⟩B)∣0⟩A∣0⟩Q.(\alpha_0|0\rangle_B+\alpha_1|1\rangle_B)|0\rangle_A|0\rangle_Q. Celelalte rezultate ale măsurătorii lui Alice produc stări diferite pentru Bob. Acestea sunt adunate în tabelul de mai jos.

Rezultatul lui AliceStarea lui BobInstrucțiune pentru BobRezultat
∣0⟩A∣0⟩Q \vert 0\rangle_A \vert 0\rangle_Qα0∣0⟩B+α1∣1⟩B\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_BNimicα0∣0⟩B+α1∣1⟩B\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B
∣0⟩A∣1⟩Q \vert 0\rangle_A \vert 1\rangle_Qα0∣0⟩B−α1∣1⟩B\alpha_0\vert 0\rangle_B-\alpha_1\vert 1\rangle_BZZα0∣0⟩B+α1∣1⟩B\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B
∣1⟩A∣0⟩Q \vert 1\rangle_A \vert 0\rangle_Qα1∣0⟩B+α0∣1⟩B\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_BXXα0∣0⟩B+α1∣1⟩B\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B
∣1⟩A∣1⟩Q \vert 1\rangle_A \vert 1\rangle_Q−α1∣0⟩B+α0∣1⟩B-\alpha_1\vert 0\rangle_B+\alpha_0\vert 1\rangle_BXX apoi ZZα0∣0⟩B+α1∣1⟩B\alpha_0\vert 0\rangle_B+\alpha_1\vert 1\rangle_B
Pentru toate rezultatele posibile ale măsurătorii pe Qubit-urile lui Alice, Qubit-ul lui Bob rămâne într-o stare care seamănă vag cu starea secretă inițial de pe Q. În cazul în care Alice măsoară $0\rangle_C0\rangle_A(primulra^ndaltabelului),Qubit−ulluiBobestela˘satexactı^nstareasecreta˘!I^ncelelaltecazuri,exista˘cevaneregulatcustarea.Coeficienții( (primul rând al tabelului), Qubit-ul lui Bob este lăsat exact în starea secretă! În celelalte cazuri, există ceva neregulat cu starea. Coeficienții (\alpha)suntinversați,sauexista˘unsemn„−"undeartrebuisa˘fieun„+",sauambele.PentruamodificaQubit−ulluiBobastfelı^nca^tsa˘fieexactegalcustareasecreta˘,Alicetrebuiesa˘ı^lsunepeBob(sa˘foloseasca˘unmijlocdecomunicareclasica˘)șisa˘ı^ispuna˘sa˘efectuezeoperațiisuplimentarepeQubit−ulsa˘u,dupa˘cumesteprezentatı^ntabel.Deexemplu,ı^naltreileara^ndcoeficiențiisuntinversați.Daca˘Aliceı^lsuna˘peBobșiı^ispunesa˘apliceunGate) sunt inversați, sau există un semn „-" unde ar trebui să fie un „+", sau ambele. Pentru a modifica Qubit-ul lui Bob astfel încât să fie exact egal cu starea secretă, Alice trebuie să îl sune pe Bob (să folosească un mijloc de comunicare clasică) și să îi spună să efectueze operații suplimentare pe Qubit-ul său, după cum este prezentat în tabel. De exemplu, în al treilea rând coeficienții sunt inversați. Dacă Alice îl sună pe Bob și îi spune să aplice un Gate XpeQubit−ulsa˘u,acestaschimba˘unpe Qubit-ul său, acesta schimbă un0\ranglecuuncu un

Acum ar trebui să fie clar de ce nu putem folosi această configurație pentru a trimite informații mai repede decât lumina. S-ar putea să avem noroc și să măsurăm ∣0⟩A∣0⟩Q,|0\rangle_A|0\rangle_Q, ceea ce înseamnă că Bob are exact starea secretă, instantaneu. Dar Bob nu știe asta până când nu îl sunăm și nu îi spunem „Am măsurat ∣0⟩A∣0⟩Q|0\rangle_A|0\rangle_Q, deci nu trebuie să faci nimic."

În experimentul mental, Qubit-urile sunt adesea separate fizic și duse într-o locație nouă. Calculatoarele cuantice IBM® folosesc Qubit-uri cu stare solidă pe un cip care nu pot fi separate. Deci, în loc să mutăm Alice și Bob în locații diferite, vom separa informațiile pe cip folosind așa-numitele „swap gate-uri" pentru a muta informațiile de la un Qubit la altul.

Experimentul 1: Teleportare de bază​

IBM Quantum recomandă abordarea problemelor de calcul cuantic folosind un cadru pe care îl numim „Qiskit patterns". Acesta constă în următorii pași.

  • Pasul 1: Mapează problema ta pe un Circuit cuantic
  • Pasul 2: Optimizează-ți Circuit-ul pentru rularea pe hardware cuantic real
  • Pasul 3: Execută-ți job-ul pe calculatoarele cuantice IBM folosind Runtime Primitives
  • Pasul 4: Post-procesează rezultatele

Pasul 1: Mapează problema ta pe un Circuit cuantic​

Tot ce am calculat mai sus a reprezentat schița pasului 1. Îl vom implementa acum, construind Circuit-ul nostru cuantic cu Qiskit! Începem prin a crea un Circuit cuantic cu trei Qubiți și prin a întreca cei doi Qubiți ai lui Alice și ai lui Bob. Îi vom numi Qubiții 1 și 2, iar Qubitul 0 îl rezervăm pentru starea secretă.

# 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")

Output of the previous code cell

Asta e tot ce trebuie să facem pentru ca starea lui Alice să fie teleportată la Bob. Totuși, reamintește-ți că atunci când măsurăm o stare cuantică α0∣0⟩+α1∣1⟩\alpha_0 |0\rangle+\alpha_1|1\rangle obținem fie ∣0⟩|0\rangle, fie ∣1⟩.|1\rangle. Așadar, la finalul acestui proces, Bob are cu siguranță starea secretă a lui Alice, dar nu o putem verifica ușor printr-o măsurătoare. Pentru ca o măsurătoare să ne confirme că am procedat corect, trebuie să recurgem la un truc. Am avut un operator numit „U" pentru „unitar", pe care l-am folosit pentru a pregăti starea secretă a lui Alice. Putem aplica inversul lui U la sfârșitul Circuit-ului nostru. Dacă U a transformat starea ∣0⟩|0\rangle a lui Alice în α0∣0⟩+α1∣1⟩\alpha_0 |0\rangle+\alpha_1|1\rangle, atunci inversul lui U va transforma α0∣0⟩+α1∣1⟩\alpha_0 |0\rangle+\alpha_1|1\rangle al lui Bob înapoi în ∣0⟩.|0\rangle. Prin urmare, această ultimă parte nu ar fi neapărat necesară dacă scopul ar fi doar mutarea informației cuantice. O facem doar pentru a ne verifica singuri.

# 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")

Output of the previous code cell

Dacă am procedat corect, măsurătoarea pe Qubitul lui Bob ar trebui să producă starea ∣0⟩|0\rangle. Desigur, aceste măsurători sunt probabilistice. Astfel, dacă există chiar și o șansă mică de a măsura Qubitul lui Bob în starea ∣1⟩|1\rangle, o singură măsurătoare ar putea da ∣1⟩.|1\rangle. Am dori cu adevărat să facem multe măsurători pentru a ne asigura că probabilitatea de ∣0⟩|0\rangle este destul de ridicată.

Pasul 2: Optimizează problema pentru execuție cuantică​

Acest pas ia operațiile pe care dorim să le efectuăm și le exprimă în termenii funcționalității unui calculator cuantic specific. De asemenea, mapează problema noastră pe arhitectura calculatorului cuantic.

Vom începe prin a încărca câteva pachete necesare pentru comunicarea cu calculatoarele cuantice IBM. Trebuie să selectăm și un Backend pe care să rulăm. Putem alege Backend-ul cel mai puțin ocupat sau putem selecta un Backend specific ale cărui proprietăți le cunoaștem.

Mai jos există cod pentru salvarea acreditărilor la prima utilizare. Asigură-te că ștergi aceste informații din notebook după ce le-ai salvat în mediul tău, pentru ca acreditările tale să nu fie partajate accidental atunci când distribui notebook-ul. Consultă Configurează-ți contul IBM Cloud și Inițializează serviciul într-un mediu neîncredibil pentru îndrumare suplimentară.

# 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

Activăm explicit logica pe măsurători.

from qiskit.circuit import IfElseOp

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

Acum trebuie să „transpilăm" Circuit-ul cuantic. Acest lucru implică mai mulți subpași și este un subiect fascinant. Ca exemplu de subpas: nu toate calculatoarele cuantice pot implementa direct toate Gate-urile logice din Qiskit. Trebuie să scriem Gate-urile din Circuit-ul nostru în termenii Gate-urilor pe care calculatorul cuantic le poate implementa. Putem realiza acest proces și altele folosind un manager de pași preset. Setarea optimization = 3 (cel mai înalt nivel de optimizare) asigură că maparea de la Circuit-ul nostru cuantic abstract la instrucțiunile date calculatorului cuantic este cât de eficientă poate fi procesarea noastră preliminară.

# 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" este o primitivă concepută pentru a eșantiona stările posibile rezultate dintr-un Circuit cuantic și pentru a colecta statistici despre ce stări ar putea fi măsurate și cu ce probabilitate. Importăm aici Sampler-ul Qiskit Runtime:

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

sampler = Sampler(mode=backend)

Nu toate calculele pe un calculator cuantic pot fi simulate rezonabil pe calculatoare clasice. Această teleportare simplă cu siguranță poate fi simulată, dar nu este deloc surprinzător că putem salva clasic informații dintr-un loc în altul. Recomandăm cu tărie efectuarea acestor calcule folosind un calculator cuantic IBM real. Dar în cazul în care ai epuizat utilizarea lunară gratuită sau dacă ceva trebuie finalizat în clasă și nu poate aștepta în coadă, acest modul poate fi completat folosind un simulator. Pentru a face asta, pur și simplu rulează celula de mai jos și decomentează liniile asociate în pașii „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)

Pasul 3: Execuție​

Folosește Sampler-ul pentru a rula jobul tău, cu Circuit-ul ca argument.

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

Pasul 4: Post-procesare și analiză​

Să reprezentăm grafic rezultatele și să le interpretăm.

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

plot_histogram(counts)

Output of the previous code cell

Verifică-ți înțelegerea​

Citește întrebarea de mai jos, gândește-te la răspuns, apoi apasă pe triunghi pentru a dezvălui soluția.

Care dintre stările de mai sus indică teleportarea reușită și cum îți dai seama?

Răspuns:

Stările ∣000⟩,|000\rangle, ∣001⟩,|001\rangle, ∣010⟩,|010\rangle, ∣011⟩|011\rangle sunt toate compatibile cu teleportarea reușită. Aceasta pentru că am adăugat un Gate pentru a anula pregătirea inițială a stării secrete. Dacă starea secretă a fost teleportată cu succes la Qubitul lui Bob, acel Gate suplimentar ar trebui să returneze Qubitul lui Bob la starea ∣0⟩.|0\rangle. Astfel, orice stare de mai sus în care Qubitul lui Bob (Qubitul 0, măsurat și în componenta 0 a registrului clasic, deci cel mai semnificativ/din dreapta) se află în starea ∣0⟩|0\rangle indică succesul.

Această reprezentare grafică arată toate rezultatele măsurătorilor pentru cei trei Qubiți, pe parcursul a 5.000 de încercări sau „shots". Am menționat anterior că Alice ar măsura toate stările posibile pentru Qubiții A și Q cu probabilitate egală. Am atribuit Qubiții 0-2 din Circuit lui Q, A și respectiv B. În notația little-endian, Qubitul lui Bob este cel mai din stânga/cel mai puțin semnificativ. Astfel, cele patru bare din stânga corespund Qubitului lui Bob aflat în ∣0⟩|0\rangle, iar ceilalți doi Qubiți se găsesc în toate combinațiile posibile cu probabilitate aproximativ egală. Observă că aproape toate (de obicei ~95%) măsurătorile produc Qubitul lui Bob în starea ∣0⟩|0\rangle, ceea ce înseamnă că configurația noastră a avut succes! Există câteva shots (~5%) care au produs Qubitul lui Bob în starea ∣1⟩|1\rangle. Acest lucru nu ar trebui să fie posibil din punct de vedere logic. Cu toate acestea, toate calculatoarele cuantice moderne suferă de zgomot și erori într-o măsură mult mai mare decât calculatoarele clasice. Iar corecția erorilor cuantice este încă un domeniu emergent.

Experimentul 2: Teleportarea pe tot procesorul​

Cel mai interesant aspect al teleportării cuantice este, fără îndoială, că o stare cuantică poate fi teleportată pe distanțe mari instantaneu (deși comunicarea clasică a Gate-urilor suplimentare nu este instantanee). Așa cum am menționat deja, nu putem desprinde Qubiții de pe procesor și să îi mutăm prin spațiu. Dar putem transfera informația de la un Qubit la altul, până când Qubiții implicați în teleportare se află pe laturi opuse ale procesorului. Să repetăm pașii de mai sus, dar de această dată vom construi un Circuit mai mare, cu suficienți Qubiți pentru a acoperi întregul procesor.

Pasul 1: Mapează problema ta pe un Circuit cuantic​

De data aceasta, qubiții corespunzători lui Alice și Bob se vor schimba. Prin urmare, nu vom numi un singur Qubit „A" și altul „B". În schimb, vom numerota qubiții și vom folosi variabile pentru a reprezenta poziția curentă a informației pe qubiții aparținând lui Alice și Bob. Toți ceilalți pași, cu excepția porților swap, sunt descriși anterior.

# 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")

Output of the previous code cell

Poți vedea în diagrama Circuit-ului că pașii logici sunt aceiași. Singura diferență este că am folosit porțile swap pentru a aduce starea Qubit-ului lui Alice de la Qubit-ul 6 (A5A_5) până la Qubit-ul 1 (A0A_0), chiar lângă Q. Și am folosit porți swap pentru a aduce starea inițială a lui Bob de la Qubit-ul 7 (B0B_0) până la Qubit-ul 12 (B5B_5). Observă că starea de pe Qubit-ul 12 nu este legată de starea secretă a lui Q până când nu se fac măsurători pe qubiții îndepărtați 0 și 1, iar starea de pe Qubit-ul 12 nu este egală cu starea secretă decât după ce sunt aplicate porțile condiționate XX și ZZ.

Pasul 2: Optimizează-ți Circuit-ul​

În mod normal, când folosim managerul de pași (pass manager) pentru a transpila și optimiza Circuit-urile noastre, are sens să setăm optimization_level = 3, deoarece dorim ca Circuit-urile noastre să fie cât mai eficiente posibil. În acest caz, nu există niciun motiv computațional pentru care să transferăm stările de pe qubiții 6 și 7 pe qubiții 1 și 12. A fost doar ceva ce am făcut pentru a demonstra teleportarea pe o distanță. Dacă cerem managerului de pași să optimizeze Circuit-ul nostru, acesta va realiza că nu există niciun motiv logic pentru aceste porți swap și le va elimina, efectuând operațiile de porți pe qubiții adiacenți. Prin urmare, pentru acest caz special, folosim 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

Putem vizualiza unde pe procesorul cuantic se află acești qubiți folosind funcția plot_circuit_layout.

Pasul 3: Execuție​

Ca și înainte, recomandăm rularea pe computere cuantice IBM reale. Dacă limita lunară gratuită a fost atinsă, nu ezita să decomentezi celulele cu simulatorul pentru a rula pe un simulator.

# 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)

Output of the previous code cell

Pasul 4: Post-procesare clasică​

Din nou, observăm că probabilitățile pentru rezultatele posibile ale qubiților lui Alice sunt destul de uniforme. Există o preferință clară pentru găsirea Qubit-ului lui Bob în ∣0⟩|0\rangle după inversarea codului secret, ceea ce înseamnă că există o probabilitate mare să fi teleportat corect starea secretă de-a lungul procesorului de la Q la Bob (qubiții 0 la 12). Cu toate acestea, observăm că există acum o șansă mai mare de a nu măsura ∣0⟩|0\rangle pentru Bob. Aceasta este o lecție importantă în computația cuantică: cu cât ai mai multe porți, în special porți multi-qubit precum porțile swap, cu atât vei întâlni mai mult zgomot și mai multe erori.

Întrebări​

Instructorii pot solicita versiuni ale acestor notebookuri cu chei de răspuns și îndrumare privind plasarea în curricule comune, completând acest sondaj rapid despre modul în care sunt folosite notebookurile.

Concepte esențiale​

  • Qubiții pot fi entanglați, ceea ce înseamnă că măsurarea unui Qubit afectează sau chiar determină starea altui Qubit.
  • Entanglarea diferă de corelațiile clasice; de exemplu, qubiții A și B ar putea fi în superpozitia stărilor α0∣00⟩+α1∣11⟩.\alpha_0|00\rangle+\alpha_1|11\rangle. Starea lui A sau B ar putea fi nedeterminată de natură, și totuși A și B ar putea fi garantate că se află în aceeași stare.
  • Printr-o combinație de entanglări și măsurători, putem transfera o stare (care poate stoca informații) de la un Qubit la altul. Acest transfer poate fi realizat chiar și pe distanțe mari, și acesta se numește teleportare cuantică.
  • Teleportarea cuantică se bazează pe măsurători cuantice, care sunt probabilistice. Prin urmare, comunicarea clasică poate fi necesară pentru a ajusta stările teleportate. Aceasta împiedică teleportarea cuantică să transmită informații mai repede decât lumina. Teleportarea cuantică nu încalcă relativitatea sau cauzalitatea.
  • Calculatoarele cuantice moderne sunt mai susceptibile la zgomot și erori decât calculatoarele clasice. Estimează câteva procente de eroare.
  • Cu cât adaugi mai multe porți în secvență (în special porți cu 2 qubiți), cu atât poți estima mai multe erori și zgomot.

Întrebări adevărat/fals​

  1. A/F Teleportarea cuantică poate fi folosită pentru a trimite informații mai repede decât lumina.
  2. A/F Dovezile moderne sugerează că colapsul unei stări cuantice se propagă mai repede decât lumina.
  3. A/F În Qiskit, qubiții sunt ordonați în stări cu Qubit-ul cu numărul cel mai mic în dreapta, ca în ∣q3,q2,q1,q0⟩|q_3,q_2,q_1, q_0\rangle

Întrebări cu variante multiple​

  1. Qubiții A și B sunt entanglați, apoi separați printr-o distanță mare dd. Qubit-ul A este măsurat. Care afirmație este corectă cu privire la viteza cu care este afectată starea Qubit-ului B?
  • a. Qubit-ul B este afectat instantaneu, în limitele toleranței experimentale, în experimentele realizate până acum.
  • b. Qubit-ul B este afectat după un timp d/cd/c, ceea ce înseamnă că starea cuantică „colapsează" aproximativ la viteza luminii, în limitele toleranței experimentale.
  • c. Qubit-ul B este afectat doar după ce a avut loc comunicarea clasică, adică se întâmplă într-un timp mai mare decât d/cd/c.
  • d. Niciuna dintre cele de mai sus
  1. Reamintește că probabilitatea de măsurare este legată de amplitudinile din stările cuantice. De exemplu, dacă un Qubit este inițial în starea α0∣0⟩+α1∣1⟩,\alpha_0|0\rangle+\alpha_1 |1\rangle, probabilitatea de a măsura starea ∣0⟩|0\rangle este ∣α0∣2.|\alpha_0|^2. Nu toate seturile de măsurători vor corespunde exact acestor probabilități, din cauza eșantionării finite (la fel cum aruncarea unui ban poate da cap de două ori la rând). Histograma de măsurători de mai jos ar putea corespunde cărei dintre următoarele stări cuantice? Selectează cea mai bună opțiune.

entangled_teleportation_fig

  • a. ∣0⟩|0\rangle
  • b. 12(∣0⟩−∣1⟩)\frac{1}{\sqrt{2}}\left(|0\rangle-|1\rangle\right)
  • c. 12(∣0⟩+∣1⟩)\frac{1}{\sqrt{2}}\left(|0\rangle+|1\rangle\right)
  • d. 45∣0⟩+35∣1⟩\frac{4}{5}|0\rangle+\frac{3}{5}|1\rangle
  • e. 35∣0⟩+45∣1⟩\frac{3}{5}|0\rangle+\frac{4}{5}|1\rangle
  1. Care dintre stările de mai jos arată qubiții A și B entanglați? Selectează toate variantele aplicabile.
  • a. 12(∣0⟩B∣0⟩A+∣1⟩B∣1⟩A)\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)
  • b. 45∣0⟩B∣0⟩A+35∣1⟩B∣1⟩A\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A
  • c. 12(∣0⟩B∣1⟩A−∣1⟩B∣0⟩A)\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)
  • d. 12(∣0⟩B∣0⟩A+∣1⟩B∣0⟩A)\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|0\rangle_A\right)
  • e. ∣0⟩B∣0⟩A|0\rangle_B|0\rangle_A
  1. În acest modul, am pregătit o stare entanglată: 12(∣0⟩B∣0⟩A+∣1⟩B∣1⟩A).\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right). Dar există multe alte stări entanglate care ar putea fi folosite pentru un protocol similar. Care dintre stările de mai jos ar putea produce o histogramă de măsurători cu 2 qubiți precum cea de mai jos? Selectează cel mai bun răspuns.

entangled_teleportation_fig_0110

  • a. 12(∣0⟩B∣0⟩A+∣1⟩B∣1⟩A)\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)
  • b. 45∣0⟩B∣0⟩A+35∣1⟩B∣1⟩A\frac{4}{5}|0\rangle_B|0\rangle_A+\frac{3}{5}|1\rangle_B|1\rangle_A
  • c. 12(∣0⟩B∣1⟩A−∣1⟩B∣0⟩A)\frac{1}{\sqrt{2}}\left(|0\rangle_B|1\rangle_A-|1\rangle_B|0\rangle_A\right)
  • d. 45∣0⟩B∣1⟩A+35∣1⟩B∣0⟩A\frac{4}{5}|0\rangle_B|1\rangle_A+\frac{3}{5}|1\rangle_B|0\rangle_A
  • e. ∣0⟩B∣0⟩A|0\rangle_B|0\rangle_A

Întrebări de discuție​

  1. Descrie protocolul de teleportare cuantică, de la început până la sfârșit, partenerului/grupului tău. Vezi dacă au ceva de adăugat sau dacă au întrebări.

  2. Există ceva unic în privința stării inițiale entanglate dintre Alice și Bob: 12(∣0⟩B∣0⟩A+∣1⟩B∣1⟩A)?\frac{1}{\sqrt{2}}\left(|0\rangle_B|0\rangle_A+|1\rangle_B|1\rangle_A\right)? Dacă da, ce anume este unic? Dacă nu, ce alte stări entanglate am fi putut folosi?

Sursă: IBM Quantum docs — actualizat 15 mai 2026
Versiunea în engleză pe doQumentation — actualizată 15 mai 2026
Această traducere se bazează pe versiunea în engleză din aproximativ 14 apr. 2026
Problemă cu site-ul sau cu traducerea?Problemă de conținut? Editează pe IBM Quantum docs