Monede Cuantice — un modul despre superpozițe și interferență

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 Install Qiskit. Pentru a putea rula joburi pe calculatoare cuantice reale, studenții vor trebui să își creeze un cont IBM Quantum® urmând pașii din ghidul Set up your IBM Cloud account.

Acest modul a fost testat și a folosit 47 de secunde de timp QPU. Aceasta este doar o estimare. Utilizarea ta efectivă poate varia.

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy qiskit 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 de Dr. Katie McCormick mai jos sau dă click aici pentru a o viziona pe YouTube.

---

Introducere

În acest modul, vom explora unul dintre principiile fundamentale ale teoriei cuantice: superpozița. În experiența noastră de zi cu zi, obiectele au întotdeauna proprietăți bine definite. Locația, dimensiunea, forma, culoarea — totul despre ele — este determinat și cert, chiar dacă noi, observatorii, nu le-am măsurat încă. În lumea cuantică, acest lucru nu este neapărat valabil. Un obiect cuantic poate fi în ceea ce se numește o „superpozițe" a mai multor stări permise clasic. Când superpozița este măsurată, aceasta va „colasa" aleatoriu într-una dintre acele stări.

Într-un fel, măsurarea unei stări de superpozițe este ca aruncarea unei monede: nu există nicio modalitate de a știi dinainte pe ce parte va cădea. Acest indeterminism fundamental este un aspect incomod al mecanicii cuantice cu care chiar și Einstein a avut dificultăți. El a spus celebrul: „Dumnezeu nu joacă zaruri" despre această aleatoritate. Dar, după cum vom vedea, Dumnezeu joacă de fapt zaruri — și aruncă monede.

Vom considera aruncarea unei monede clasice ca o analogie pentru măsurarea unei stări de superpozițe. Și — jucând cu o „monedă cuantică" folosind Qiskit și un qubit pe un procesor cuantic IBM® — vom descoperi rapid limitele acestei analogii.

Moneda clasică

Să începem cu o monedă clasică. Aruncă o monedă și va cădea fie cu fața în sus, fie cu fața în jos, cu o probabilitate de 50$~$% pentru fiecare variantă. Deși în principiu cineva ar putea calcula pe ce parte va cădea moneda dacă ar cunoaște condițiile inițiale precise și forța/momentul de torsiune al aruncării, în practică nu există nicio modalitate de a ști a priori pe ce parte va cădea. De aceea folosim aruncarea monedei ca exemplu canonic al unei stări probabilistice clasice, unde rezultatul este în esență aleatoriu. Putem scrie starea monedei înainte de a ateriza pentru a reflecta această probabilitate 50/50:

$$S(coin) = \frac{1}{2}|up\rangle + \frac{1}{2}|down\rangle$$

Aici, cei doi termeni reprezintă cele două rezultate posibile ale aruncării, iar coeficienții lor reprezintă probabilitățile fiecărui rezultat. Observă că, de obicei, „$|\rangle$" (cunoscut sub numele de „ket") este folosit pentru a reprezenta o stare cuantică, dar aici vorbim despre o stare probabilistică clasică. Consultă Lecția 1: Sisteme Unice din cursul Basics of Quantum Information pentru a afla mai multe despre cum reprezentăm informația clasică și cuantică.

Dacă am arunca o monedă de 1000 de ori și am înregistra numărul de rezultate cu fața în sus și cu fața în jos, am obține ceva de genul:

# import necessary packages:
import numpy as np
import matplotlib.pyplot as plt
import random

nflips = 1000
fliplist = [random.randint(0, 1) for f in range(nflips)]

# bar plots using get_gaussian_probs function
plt.hist(fliplist)
plt.show()

Monedă cuantică

Putem crea o stare probabilistică similară folosind un qubit pe calculatorul nostru cuantic. Ca și la aruncarea monedei, un qubit poate fi măsurat în două stări posibile: $|0\rangle$ și $|1\rangle$. Creăm starea probabilistică de „superpoziție" pornind din starea $|0\rangle$ și apoi aplicând qubitului ceva numit poartă Hadamard. Aceasta îl plasează într-o superpoziție egală de $|0\rangle$ și $|1\rangle$. Notează că, deși această stare de superpoziție poate părea și se poate comporta la prima vedere ca moneda, vom vedea în curând că este mult mai mult decât atât. Scopul acestui modul este să îți arate că o superpoziție nu este același lucru cu o aruncare clasică a monedei.

Deci, deoarece qubitului se află într-o superpoziție egală de 0 și 1, atunci când îl măsurăm, există o probabilitate de 50% să măsurăm $|0\rangle$ și o probabilitate de 50% să măsurăm $|1\rangle$. Scriem această stare puțin diferit față de cazul probabilistic clasic, din motive care vor deveni clare mai târziu:

$$|\psi\rangle = \frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle$$

Aici, probabilitățile de a măsura fiecare dintre cele două stări nu mai sunt egale cu coeficienții, cum era cazul în starea probabilistică clasică de mai sus. În schimb, pătratul coeficienților ne dă probabilitățile, iar fiecare dintre acești coeficienți poate fi acum complex, adică poate avea atât parte reală, cât și parte imaginară.

Cu toate aceste diferențe, totuși, rezultatul măsurării acestei stări este practic același cu aruncarea unei monede.

from qiskit import QuantumCircuit

qcoin = QuantumCircuit(1)
qcoin.h(0)
qcoin.measure_all()

qcoin.draw("mpl")

Deci, în esență, aplicarea porții Hadamard este analogul aruncării unei monede. Și, la fel cum am aruncat moneda de 1000 de ori pentru a analiza statisticile cu care aterizează cu fața în sus sau în jos, putem face ceva similar în Qiskit cu „moneda noastră cuantică." Putem folosi un primitiv Qiskit numit Sampler, care va repeta un circuit de mai multe ori pentru a eșantiona statisticile stării rezultate.

Mai întâi, încărcăm serviciul Qiskit Runtime și primitivele, apoi selectăm un backend pe care să rulăm circuitul.

Mai jos există cod pentru salvarea acreditivelor la prima utilizare. Asigură-te că ștergi aceste informații din notebook după ce le-ai salvat în mediul tău, astfel încât acreditivele 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încrezător pentru mai multe îndrumări.

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

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

# Load the Runtime primitive and session
from qiskit_ibm_runtime import (
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
)

# Use the least busy backend
backend = service.least_busy()
print(backend.name)

ibm_kingston

Dacă nu mai ai timp disponibil în contul tău, poți alege să rulezi aceasta pe un simulator. Decomentează codul și rulează celula de mai jos pentru a face asta:

## Use a local simulator

# from qiskit_aer import AerSimulator

## Generate a simulator that mimics the real quantum system

# backend_sim = AerSimulator.from_backend(backend)

## Import an estimator, this time from qiskit (we will import from Runtime for real hardware)

# from qiskit.primitives import BackendSamplerV2
# sampler_sim = BackendSamplerV2(backend = backend_sim)
# from qiskit.primitives import BackendEstimatorV2
# estimator_sim = BackendEstimatorV2(backend = backend_sim)

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

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

counts = res[0].data.meas.get_counts()

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analysis
from qiskit.visualization import plot_histogram

plot_histogram(counts)

Cu 1000 de eșantioane ale circuitului de mai sus, obținem ceva care arată practic identic cu histograma monedei clasice, cu unele fluctuații statistice.

Pe lângă eșantionarea statisticilor monedei cuantice, putem folosi și un alt primitiv Qiskit numit Estimator pentru a măsura așa-numita valoare de așteptare a unui observabil al stării. Pentru a ilustra ce este această valoare de așteptare, să folosim moneda clasică ca exemplu. Să zicem că folosești moneda pentru a juca: de fiecare dată când arunci moneda și aterizează cu „fața în sus," câștigi un dolar. Dar de fiecare dată când aterizează cu „fața în jos," pierzi un dolar. Dacă vrei să știi câți bani te aștepți să câștigi la fiecare aruncare (valoarea de așteptare a observabilului „bani"), atunci ai calcula:

$$E(money) = \frac{1}{2} (+ \text{1 dollar}) + \frac{1}{2} (- \text{1 dollar}) = \text{0 dollars}$$

Deoarece este la fel de probabil să câștigi un dolar pe cât este să pierzi un dolar, valoarea de așteptare este $0.

Similar, cu o stare cuantică, putem calcula valoarea de așteptare a observabilului „Z", unde Z este matricea Pauli cu valorile +1 și -1 asociate stărilor $|0\rangle$ și respectiv $|1\rangle$.

$$\langle \psi|Z|\psi \rangle = \frac{1}{2} \langle 0 | Z | 0 \rangle + \frac{1}{2} \langle 1 | Z | 1 \rangle = \frac{1}{2} (+1) + \frac{1}{2}(-1) = 0$$

from qiskit.quantum_info import Pauli

qcoin = QuantumCircuit(1)
qcoin.h(0)

# for Estimator, we do not apply the measurement to the circuit

<qiskit.circuit.instructionset.InstructionSet at 0x136df1ba0>

## Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

obs = Pauli("Z")

qc_isa = pm.run(qcoin)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

## Execute

# On real hardware:
estimator = Estimator(mode=backend)
pubs = [(qc_isa, obs_isa)]
job = estimator.run([[qc_isa, obs_isa]])
res = job.result()

# On a simulator:
# job = estimator_sim.run([[qc_isa, obs_isa]])
# res=job.result()

print(res[0].data.evs)

-0.014799284701239441

Obținem o valoare de așteptare de 0, conform așteptărilor (hah). Aceasta este o altă modalitate de a confirma că într-adevăr există o probabilitate egală de a măsura 0 și 1, și că se comportă ca o aruncare a monedei.

În acest punct, „moneda cuantică" arată exact ca moneda clasică. Dar în secțiunea următoare, vom face câteva experimente care vor dezvălui diferențele fundamentale dintre cele două.

Cuantumul dezvăluit: un experiment în trei dimensiuni

Să facem un experiment mintal: Imaginează-ți că arunci o monedă în aer și, în loc să o lași să cadă pe jos, ai îndemânarea să bați din palme exact când trece între mâini și să o prinzi sandwich între palme. Acum, în loc să fie capul în sus sau în jos, moneda e cu capul spre stânga sau spre dreapta.

Verifică-ți înțelegerea

Citește întrebarea (întrebările) de mai jos, gândește-te la răspuns, apoi apasă pe triunghi pentru a vedea soluția.

Care este probabilitatea fiecăruia dintre aceste rezultate: capul spre stânga sau capul spre dreapta?

Răspuns:

Probabilitatea va fi în continuare 50-50. Nu ar trebui să conteze de-a lungul cărui ax alegem să măsurăm rezultatul aruncării monedei.

Sperăm că ai răspuns că probabilitatea de a găsi capul spre stânga sau spre dreapta este tot 50-50. Dimensiunea de-a lungul căreia se măsoară aruncarea monedei nu ar trebui să afecteze probabilitatea rezultatelor.

Dar cum ar arăta lucrurile diferit pentru moneda noastră cuantică? Să verificăm.

Putem crea superpozița cuantică în același mod ca data trecută, cu o poartă Hadamard. Pentru a măsura „capul spre stânga sau spre dreapta" pe moneda noastră cuantică, putem face ceea ce am făcut cu moneda clasică: să măsurăm de-a lungul unui ax diferit. Măsurătorile noastre standard pe calculatorul cuantic sunt de-a lungul axei verticale, la fel ca măsurătoarea obișnuită „cap sus sau jos" a monedei clasice. Dar putem, de asemenea, să întrebăm moneda noastră cuantică dacă are capul spre stânga sau spre dreapta, sau echivalent, dacă se află în stările $|+\rangle$ sau $|-\rangle$, care indică de-a lungul axei $x$. Sampler eșantionează doar în baza de măsurare Z, dar putem folosi Estimator pentru a ne oferi valoarea de așteptare a lui X. Valorile lui X sunt +1 și -1 pentru stările $|+\rangle$, respectiv $|-\rangle$.

Verifică-ți înțelegerea

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

Dacă moneda cuantică s-ar comporta ca moneda clasică în acest caz, am avea o probabilitate 50-50 de a măsura starea ca fiind $|+\rangle$ sau $|-\rangle$. Ce valoare de așteptare a lui X ne-am aștepta să returneze Estimator, dacă acesta ar fi cazul?

Răspuns:

Când aplicăm X stării $|+\rangle$, obținem valoarea +1, iar stării $|-\rangle$ obținem -1, deci dacă am avea o distribuție 50-50, am obține o valoare de așteptare de 0.

# Step 1: map problem

qcoin_lr = QuantumCircuit(1)
qcoin_lr.h(0)

obs = Pauli("X")

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qcoin_lr)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

estimator = Estimator(mode=backend)
pubs = [(qc_isa, obs_isa)]
job = estimator.run([[qc_isa, obs_isa]])
res = job.result()

# Run the job on the Aer simulator with noise model from real backend
# job = estimator_sim.run([[qc_isa,obs_isa]])
# res=job.result()

# Step 4: Return the result in classical form, and analyze.

print(res[0].data.evs)

0.9985207100591716

Valoarea de așteptare a lui X pentru această stare este 1. Deci, nu există o probabilitate 50-50 de a măsura $|+\rangle$ și $|-\rangle$.

Verifică-ți înțelegerea

Citește întrebarea (întrebările) de mai jos, gândește-te la răspuns, apoi apasă pe triunghi pentru a vedea soluția.

Ce ne spune această valoare de așteptare despre starea $|\psi\rangle$? Care sunt probabilitățile de a măsura $|+\rangle$ și $|-\rangle$ în această bază X?

Răspuns:

Deoarece valoarea de așteptare este aceeași cu valoarea lui X pentru starea $|+\rangle$, înseamnă că avem o probabilitate de 100% de a măsura starea $|+\rangle$ atunci când măsurăm de-a lungul lui X.

Ce se întâmplă aici? Se pare că moneda noastră cuantică poate avea rezultate aleatoare, probabilistice de-a lungul unei dimensiuni, dar rezultate perfect predictibile de-a lungul alteia. Ar fi ca și cum ai arunca o monedă și ai garanta că, de fiecare dată când este prinsă prin sandwicharea între două mâini, capul ar fi mereu orientat spre dreapta.

Faza cuantică

Diferența esențială a monedei cuantice este că aceasta are o altă proprietate pe care moneda clasică nu o are. Amintește-ți că într-o stare probabilistică clasică,

$$S(coin) = c_1|up\rangle + c_2|down\rangle$$

fiecare coeficient este pur și simplu un număr real, pozitiv, care reprezintă probabilitatea de a măsura o anumită stare. Într-o stare cuantică,

$$|\psi\rangle = c_1 |0\rangle + c_2 |1\rangle$$

coeficienții sunt complecși, deci conțin o parte reală și una imaginară. Fiecare coeficient $c_i$ poate fi exprimat ca un vector bidimensional în planul complex, cu modulul $|c_i|$ și unghiul $\phi_i$ pe care îl face cu axa reală:

$$c_i = |c_i| e^{i \phi_i}.$$

Numim $\phi_i$ faza. Faza ne spune cum vor interfera doi termeni dintr-o stare cuantică, adică cum se vor aduna sau anula asemenea undelor. Dacă două unde sunt în fază una cu cealaltă, astfel încât crestele și troacele lor se aliniază, ele se vor combina pentru a forma o undă de două ori mai înaltă. Numim aceasta interferență constructivă. Dacă sunt defazate, adică o creastă dintr-una se aliniază cu un troc din cealaltă și invers, ele interferează distructiv și se anulează complet.

La fel ca undele, stările cuantice pot aduna constructiv sau distructiv. Poate fi mai greu de observat pentru că, adesea, nu vorbim despre o undă reală în spațiul fizic. În cazul qubiților noștri, interferența are loc în spațiul informațional abstract al qubiților. De reținut și că, deoarece contează doar faza relativă dintre cele două unde pentru modul în care vor interfera — adică diferența de faze $\Delta \phi = \phi_2 - \phi_1$ a celor doi coeficienți — aplicăm de obicei o fază globală de $-\phi_1$ întregii stări, astfel încât $c_1$ să fie pur real, iar faza relativă să fie capturată integral în $c_2$.

Pentru a vedea cum poate faza să cauzeze interferențe în moneda noastră cuantică, să încercăm să aplicăm Hadamard de două ori în loc de o singură dată. Clasic, acest lucru nu ar avea niciun sens — dacă aplicarea Hadamard echivalează cu aruncarea unei monede, nu poți arunca o monedă care deja se răsucește. Dar să vedem ce se întâmplă cu moneda cuantică:

qcoin_0 = QuantumCircuit(1)
qcoin_0.h(0)
qcoin_0.h(0)
qcoin_0.measure_all()

qcoin_0.draw("mpl")

Acum, înainte să folosim Sampler pentru a măsura starea rezultată, să ne gândim cum va fi transformat acest qubit de fiecare Gate. El pornește, ca de obicei, din $|0\rangle$. Apoi, primul Hadamard transformă starea în superpoziție, așa cum am văzut deja:

$$H|0\rangle = \frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle.$$

În acest caz, ambii coeficienți sunt complet reali și pozitivi, ceea ce înseamnă că faza este $\phi=0$.

Al doilea Hadamard este apoi aplicat separat fiecărei componente a stării de superpoziție. Știm deja cum transformă Hadamard starea $|0\rangle$. Dar ce se întâmplă cu $|1\rangle$?

$$H|1\rangle = \frac{1}{\sqrt{2}} |0\rangle - \frac{1}{\sqrt{2}} |1\rangle$$

Aceasta este, din nou, o superpoziție egală a lui 0 și 1, similară cu aruncarea unei monede, dar coeficientul acestei stări din fața lui $|1\rangle$ are o fază de $\phi = \pi$, ceea ce îi conferă semnul negativ.

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.

Calculează starea rezultată după aplicarea celui de-al doilea Hadamard. Adică, calculează: $H(\frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle)$. Reține că $H$ este distributiv, deci îl putem aplica fiecărui termen în parte.

Răspuns:

$$H(\frac{1}{\sqrt{2}} |0\rangle + \frac{1}{\sqrt{2}} |1\rangle) = \frac{1}{\sqrt{2}} H|0\rangle + \frac{1}{\sqrt{2}} H|1\rangle = \frac{1}{2} [(|0\rangle + |1\rangle) + (|0\rangle - |1\rangle)] = |0\rangle$$

Acum să verificăm predicția noastră cu Sampler.

## Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qcoin_0)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

counts = res[0].data.meas.get_counts()

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

Al doilea Hadamard l-a anulat pe primul, iar noi am revenit la starea 0 de la care am pornit! Acest lucru se întâmplă deoarece Hadamard transformă atât stările $|0\rangle$, cât și $|1\rangle$ în stări similare, dar cu faze opuse. După cel de-al doilea Hadamard, observăm că termenii $|0\rangle$ interferează constructiv, iar termenii $|1\rangle$ interferează destructiv și se anulează reciproc.

Să explorăm mai departe: putem schimba faza folosind o poartă „PHASE". Acum să aplicăm un Hadamard pentru a crea superpunerea, să aplicăm un decalaj de fază de $\pi$ radiani, apoi să aplicăm cel de-al doilea Hadamard:

qcoin_pi = QuantumCircuit(1)
qcoin_pi.h(0)
qcoin_pi.p(np.pi, 0)
qcoin_pi.h(0)
qcoin_pi.measure_all()

qcoin_pi.draw("mpl")

## Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qcoin_pi)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

counts = res[0].data.meas.get_counts()

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

Și acum qubit-ul este măsurat ca fiind în starea 1 în loc de 0.

Deci, chiar și din aceste câteva experimente simple, poți vedea deja diferența drastică pe care o poate face această fază într-un circuit cuantic. Poate fi subtilă și greu de observat la început. În primul nostru experiment, în care am aruncat pur și simplu moneda noastră cuantică cu o poartă Hadamard și am măsurat rezultatul, nu s-a dezvăluit nimic din efectul fazei. Abia când am aprofundat cercetarea am descoperit diferența pe care o poate face o fază. Aceasta poate face ca aceeași poartă cuantică să aibă, la propriu, efectul opus asupra unui qubit.

Încearcă tu însuți:

Editează celula de cod de mai jos pentru a schimba faza astfel încât al doilea Hadamard să creeze o stare de superpoziție cu probabilități de 25% și 75% de a găsi starea în $|0\rangle$, respectiv $|1\rangle$. Verifică răspunsul tău cu ajutorul matematicii.

qcoin_phase = QuantumCircuit(1)
qcoin_phase.h(0)
# replace "x" below with a phase from 0 to 2*np.pi (this cell won't run if you leave x)
# qcoin_phase.rz(x, 0)
qcoin_phase.h(0)
qcoin_phase.measure_all()

## Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qcoin_phase)

## Execute

# On real hardware:
sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs, shots=1000)
res = job.result()

counts = res[0].data.meas.get_counts()

# or with Aer simulator with noise model from real backend
# job = sampler_sim.run([qc_isa])
# counts=job.result()[0].data.meas.get_counts()

## Analyze
plot_histogram(counts)

O altă analogie (mai bună) cu moneda, folosind poarta $\sqrt{\text{NOT}}$

Până acum am aflat că actul de a arunca o monedă este destul de diferit de crearea unei stări de superpoziție. Există o analogie mai bună cu o monedă care să surprindă mai mult din fenomenele specifice superpoziției? Da. Chiar există.

O să facem un alt experiment de gândire cu o monedă. Imaginează-ți moneda pe masă, cu fața în sus. Pentru a o pune cu fața în jos, o putem pur și simplu întoarce. Acesta este echivalentul computațional al unei porți „NOT".

Să spunem că vrem să construim o operație care, aplicată de două ori, să fie echivalentă cu poarta NOT. Adică, vrem o „rădăcină pătrată din NOT," sau $\sqrt{\text{NOT}}$. Putem face asta luând în considerare modul în care poarta NOT este implementată fizic pe monedă: este doar o rotație de 180 de grade în jurul, de exemplu, axei x. Așadar, dacă am roti moneda cu doar 90 de grade în jurul axei x, ar fi echivalent cu o poartă $\sqrt{\text{NOT}}$.

Imaginează-ți că, după aplicarea porții $\sqrt{\text{NOT}}$, vrem să verificăm dacă moneda are fața în sus sau în jos. Nu este nici una, nici alta — stă pe muchie față de axa verticală. Dar acum, să redefinim „măsurătoarea" noastră a monedei astfel: mai întâi, prăbușim moneda de-a lungul axei de măsurare (apăsând-o cu mâna astfel încât să fie plată), și al doilea, verificăm dacă are fața în sus sau în jos.

Dacă efectuăm această „măsurătoare" pe moneda stând pe muchie, atunci moneda se va „prăbuși" cu fața în sus sau în jos cu probabilitate egală. La fel ca în cazul aruncării monedei, în principiu, direcția în care cade moneda poate fi prezisă pe baza condițiilor inițiale ale monedei și a modului exact în care se aplică forța mâinii noastre pentru a o „prăbuși". Dar în practică, ar trebui să fie dificil de prezis ce parte va cădea în sus, deci este în esență aleatorie.

De fapt, putem măsura această monedă de-a lungul a trei axe diferite: $x$, $y$ și $z$. Vedem că muchia monedei indică de-a lungul $x$ și $z$, deci măsurarea în acele direcții necesită „prăbușirea" monedei — prin urmare, de-a lungul acelor axe, va exista o probabilitate aleatorie de 50:50 de a măsura fața în sus sau în jos. Dar de-a lungul axei $y$, moneda este deja plată, cu fața îndreptată în direcția -y. Putem numi asta „față înainte."

Astfel, în timp ce măsurătorile pe x și z au dat rezultate aleatorii, măsurătoarea pe y va da întotdeauna același rezultat! Dacă îți amintești experimentul „quantum coin flip" din secțiunea anterioară, acest lucru este similar cu modul în care s-a comportat moneda cuantică. A fost măsurată ca 0 sau 1 cu probabilitate 50/50 în direcția z, dar întotdeauna $|+\rangle$ și niciodată $|-\rangle$ de-a lungul lui X. Asta sugerează că poate o monedă care stă nemișcată pe muchie este o modalitate mai bună de a vizualiza o stare de superpoziție a unui qubit decât o monedă care se rotește haotic în aer.

Să folosim Qiskit pentru a vedea dacă „moneda noastră cuantică" se comportă la fel ca moneda noastră clasică atunci când se aplică o poartă $\sqrt{\text{NOT}}$. Vom aplica $\sqrt{\text{NOT}}$ unui qubit care pornește din $|0\rangle$, apoi vom folosi Estimator pentru a verifica valoarea de așteptare a celor trei observabile, X, Y și Z.

qcoin_sx = QuantumCircuit(1)
qcoin_sx.sx(0)

qcoin_sx.draw("mpl")

obs1 = Pauli("X")
obs2 = Pauli("Y")
obs3 = Pauli("Z")

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qcoin_sx)
obs1_isa = obs1.apply_layout(layout=qc_isa.layout)
obs2_isa = obs2.apply_layout(layout=qc_isa.layout)
obs3_isa = obs3.apply_layout(layout=qc_isa.layout)

# Step 3: Run the circuit on a real quantum computer

estimator = Estimator(mode=backend)
pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]
job = estimator.run(pubs)
res = job.result()

# Run the job on the Aer simulator with noise model from real backend
# pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]])]
# job = estimator_sim.run(pubs)
# res=job.result()

# Step 4: Return the result in classical form, and analyze.

print(res[0].data.evs)

[[-0.01234492]
 [-1.00388865]
 [ 0.00740695]]

Valorile de așteptare sunt 0, -1 și 0 pentru X, Y și, respectiv, Z.

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.

Dat fiind valorile de așteptare, care sunt probabilitățile de a măsura moneda cuantică cu fața în sus/jos (sau stânga/dreapta sau înainte/înapoi) pentru fiecare dintre cele 3 axe de măsurare?

Răspuns:

Există o probabilitate de 50/50 de a măsura oricare stare de-a lungul X și Z, iar starea este întotdeauna măsurată în direcția -y de-a lungul Y.

Acesta este același rezultat pe care l-am obținut în experimentul nostru de gândire, aplicând o rotație de 90 de grade „$\sqrt{\text{NOT}}$" pe moneda clasică. De fapt, există acum o analogie precisă între monedă și starea qubitului. Putem vizualiza starea qubitului ca un vector care indică în direcția feței unei monede, normal la suprafața monedei. Astfel, fața în sus, sau starea $|0\rangle$ pe o monedă cuantică, este echivalentă cu un vector care indică direct în sus; fața în jos, sau $|1\rangle$, indică direct în jos. Orice superpoziție egală a lui $|0\rangle$ și $|1\rangle$ indică orizontal. Faza stării determină direcția orizontală exactă — direcția în care indică de-a lungul ecuatorului este egală cu direcția spre care indică coeficientul $c_2$ în planul complex.

Acum, orice poartă pe care am văzut-o în acest notebook poate fi vizualizată ca o rotație (sau o serie de rotații) a monedei/vectorului.

• NOT: 180 de grade în jurul axei x

• $\sqrt{\text{NOT}}$: 90 de grade în jurul axei x

• PHASE: rotație de $\phi$ în jurul axei z

• Hadamard: Aceasta este puțin mai complicată. Inițial am asemănat-o cu aruncarea unei monede, făcând moneda să se rotească necontrolat în aer. Dar Hadamard este de fapt o rotație controlată și deterministă a monedei, la fel ca celelalte porți. Hadamard se realizează prin rotarea cu 90 de grade în jurul axei y, urmată de 180 de grade în jurul axei x.

Deci, nu există nimic aleatoriu în privința unei stări de superpoziție cuantică sau a oricărei operații standard pe care le efectuăm pe qubit. Fiecare operație este deterministă și reversibilă. Singurul moment în care aleatoriul intră în joc este atunci când decidem să măsurăm starea cuantică.

Starea qubitului ca vector Bloch

Acest vector care indică direcția „capului" monedei este cunoscut sub numele de „vector Bloch". Formal, o stare arbitrară (izolată) a unui qubit poate fi reprezentată printr-un vector care se află pe suprafața unei sfere de rază 1, cu coordonatele $(r, \theta, \phi)$. Scrisă în termenii acestor coordonate, starea qubitului este:

$|\psi\rangle = \cos{\frac{\theta}{2}} |0\rangle + e^{i \phi} \sin{\frac{\theta}{2}} |1\rangle$

Acum să verificăm cu Qiskit cum se modifică vectorul Bloch atunci când aplicăm diverse gate-uri qubitului nostru pornind din starea $|0\rangle$.

NOT

from qiskit.visualization import plot_bloch_multivector

qnot = QuantumCircuit(1)
qnot.x(0)

plot_bloch_multivector(qnot)

$\sqrt{\text{NOT}}$

qsqrtnot = QuantumCircuit(1)
qsqrtnot.sx(0)

plot_bloch_multivector(qsqrtnot)

PHASE ($\phi = \pi$)

qphase = QuantumCircuit(1)
qphase.p(np.pi, 0)

plot_bloch_multivector(qphase)

Hadamard

qhadamard = QuantumCircuit(1)
qhadamard.h(0)

plot_bloch_multivector(qhadamard)

Concluzie - ce este, de fapt, o stare de suprapunere?

Am început acest modul comparând caracterul aleatoriu al măsurării unei stări cuantice de suprapunere cu aruncarea unei monede. Am asemănat „gate-ul Hadamard", care produce o suprapunere cuantică, cu actul de aruncare a unei monede. Dar, printr-o serie de experimente, am aflat că există diferențe fundamentale între aruncarea clasică a unei monede și suprapunerea cuantică.

Am aflat că nu există nimic cu adevărat „aleatoriu" în legătură cu un qubit aflat într-o stare de suprapunere. Este ca o monedă care stă nemișcată în spațiul tridimensional. De fapt, o monedă liberă să se rotească în 3 dimensiuni este o analogie foarte apropiată cu un mod particular de a vizualiza starea cuantică a unui qubit, numit vectorul Bloch. Gate-urile cuantice rotesc această monedă/vector Bloch în mod determinist și reversibil. Aleatoriu apare doar atunci când măsurăm qubitul. Am comparat acest proces de măsurare cu aplatizarea monedei, astfel încât aceasta să rămână plată în direcția axei de măsurare.

Dacă o stare cuantică se află sau nu într-o suprapunere depinde, de fapt, de perspectiva observatorului. Așa cum ai întâlnit probabil înainte, suntem liberi să alegem sistemul nostru de coordonate — $x$, $y$ și $z$ pot indica orice trei direcții ortogonale. Deci, dacă avem o suprapunere a lui 0 și 1 într-un sistem de coordonate, putem defini un sistem de coordonate nou — sau, echivalent, o nouă „bază de măsurare" — în care starea indică pur în direcția $+z$ și, prin urmare, nu se află într-o stare de suprapunere. Deci, atunci când spunem că un qubit se află într-o suprapunere, trebuie să răspundem și la întrebarea: „suprapunere a ce?"

S-ar putea să termini acest modul cu impresia că am eliminat tot misterul din mecanica cuantică. La urma urmei, unul dintre aspectele presupus „ciudate", starea de suprapunere a unui qubit, este de fapt la fel de simplu ca un vector tridimensional. Dar ține minte că moneda rămâne doar o analogie, iar chiar și vectorul Bloch este doar un instrument de vizualizare pentru a calcula probabilitățile rezultatelor măsurătorilor. Nu putem spune ce face cu adevărat o stare cuantică înainte de a fi măsurată. Pentru că, a verifica asta necesită o măsurătoare!

Vom discuta această dilemă despre care este natura „adevărată" a unei stări cuantice și cum fenomenul cuantic al entanglementului ne poate ajuta să elucidăm acest lucru, în modulul despre Inegalitatea Bell.

Întrebări

Instructorii pot solicita versiuni ale acestor notebook-uri cu chei de răspuns și îndrumări privind plasarea în curricule comune, completând acest sondaj rapid despre modul în care notebook-urile sunt utilizate.

Concepte critice:

• Deși măsurarea unui qubit aflat în suprapunere este probabilistică, precum aruncarea unei monede, starea de suprapunere în sine se comportă diferit față de o monedă aruncată.
• O diferență principală între o distribuție de probabilitate clasică și o suprapunere este că suprapunerea are coerență de fază, ceea ce îi permite să interfere constructiv sau distructiv.
• Starea unui singur qubit izolat poate fi vizualizată ca un punct pe așa-numita „sferă Bloch", unde amplitudinile relative ale componentelor $|0\rangle$ și $|1\rangle$ determină unghiul polar $\theta$, iar fazele relative dintre cele două componente determină unghiul azimutal $\phi$.
• Toate gate-urile cuantice cu un singur qubit pot fi privite ca rotații ale vectorului pe această sferă.

Întrebări A/F:

1. A/F O suprapunere cuantică este practic același lucru cu un eveniment probabilistic în fizica clasică, precum aruncarea unei monede.

2. A/F Lungimea vectorului Bloch care descrie starea unui singur qubit izolat este întotdeauna 1.

3. A/F Gate-urile cuantice cu un singur qubit nu modifică lungimea vectorului Bloch.

Întrebări cu variante multiple:

1. Selectează vectorul Bloch corect care reprezintă starea $|\Psi\rangle = \sqrt{\frac{1}{3}}|0\rangle + e^{i \pi / 4} \sqrt{\frac{2}{3}}|1\rangle$:

2. Sfera Bloch descrie: (selectează toate variantele corecte)

   a. amplitudinea

   b. împletirea cu alți qubiți

   c. faza

   d. culoarea

   e. probabilitatea rezultatelor măsurătorii

Întrebări de discuție:

1. De ce starea unui qubit poate fi vizualizată pe sfera Bloch, dar distribuția de probabilitate a aruncării unei monede nu poate?

2. De ce o monedă aflată în aer nu este cea mai bună analogie pentru o stare de superpozitie cuantică? Ce aspect al superpozițiilor nu este surprins în această analogie?

Probleme provocatoare:

1. Folosește Qiskit pentru a crea un circuit care transformă starea $|0\rangle$ în starea $\frac{\sqrt{3}}{2}|0\rangle + \frac{1}{2}e^{i \frac{5\pi}{6}}|1\rangle$