Paggalugad ng kawalan ng katiyakan

Para sa modyul na ito ng Qiskit in Classrooms, kailangang magkaroon ng gumaganang Python environment ang mga estudyante na may mga sumusunod na naka-install na pakete:

• qiskit v2.1.0 o mas bago
• qiskit-ibm-runtime v0.40.1 o mas bago
• qiskit-aer v0.17.0 o mas bago
• qiskit.visualization
• numpy
• pylatexenc

Para i-set up at i-install ang mga pakete sa itaas, tingnan ang gabay na I-install ang Qiskit. Para mapatakbo ang mga trabaho sa tunay na quantum computers, kailangang mag-set up ng account sa IBM Quantum® ang mga estudyante sa pamamagitan ng pagsunod sa mga hakbang sa gabay na I-set up ang iyong IBM Cloud account.

Ang modyul na ito ay nasubok at gumamit ng 8 minuto ng QPU time. Tantiya lamang ito. Maaaring mag-iba ang iyong aktwal na paggamit. Dalawang matagal na kalkulasyon ang minarkahan bilang ganoon sa mga komento ng header at maaaring isagawa sa mga simulator kung kulang ang QPU time ng mga estudyante. Kapag inalis ang mga iyon, ang modyul ay nangangailangan lamang ng ~30 segundo ng QPU time.

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib 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'

Panoorin ang walkthrough ng modyul ni Dr. Katie McCormick sa ibaba, o i-click dito para manood sa YouTube.

---

Panimula

Malamang narinig mo na ang prinsipyo ng kawalan ng katiyakan, kahit sa labas ng iyong mga kurso sa pisika. Isang karaniwang pagpapahayag ng kawalan ng katiyakan sa pang-araw-araw na wika ay: "Sa pamamagitan ng pagtingin sa isang bagay, naiimpluwensyahan mo ito." Tiyak na totoo iyon. Ngunit isang mas pisikal na paraan ng paglalarawan ng kawalan ng katiyakan ay ang may ilang mga pisikal na obserbasyon na may hindi pagkakatugma na pumipigil sa kanilang parehong malaman nang sabay-sabay nang may di-tiyak na katumpakan. Maraming estudyante ang unang nakakatagpo ng pares ng mga hindi tugmang variable na $x$ at $p_x$, ibig sabihin, ang posisyon sa isang axis na tinatawag na $x$-axis, at ang linear momentum sa direksyong iyon, ayon sa pagkakasunod. Para sa mga variable na iyon, ang hadlang sa kawalan ng katiyakan ay nakasulat bilang $\Delta x \Delta p_x \geq \frac{\hbar}{2}.$ Dito, ang $\Delta x$ ay tinatawag na "kawalan ng katiyakan sa $x$", na may parehong kahulugan bilang standard deviation sa istatistika, at maaaring tukuyin bilang $\Delta x = \sqrt{\langle x^2 \rangle - \langle x \rangle^2}.$ Ang $\Delta p_x$ ay tinukoy sa parehong paraan.

Dito, hindi namin bibigyan ng patunay ang relasyong ito ng kawalan ng katiyakan; itaturo natin na ito ay naaayon sa ating pag-unawa sa mga klasikal na alon. Ibig sabihin, ang isang alon na may tunay na iisang perpektong dalas $f$ at haba ng alon $\lambda$ ay magpapatuloy magpakailanman bilang isang perpektong sinusoid. Sa quantum mechanically, naaayon ito sa perpektong pagkaalam ng momentum ayon sa hypothesis ni de Broglie: $\lambda = h/p$. Ngunit para malaman ang kung saan matatagpuan ang isang particle na parang alon, ang alon na naglalarawan nito ay dapat maging mas matulis sa espasyo, tulad ng isang napakakitid na Gaussian, halimbawa. Alam natin na maaari nating ipahayag ang anumang patuloy na function, kasama ang mga gayong matulis na wave function, bilang isang Fourier series ng mga sinusoidal na function na may iba't ibang haba ng alon. Ngunit habang nagiging mas matulis ang wave function (at mas mahusay na nalalaman ang posisyon), kakailanganin natin ng mas maraming termino sa Fourier series, ibig sabihin, isang halo ng mas maraming haba ng alon (at sa gayon, sa quantum mechanically, mas maraming halaga ng momentum).

Mas simpleng sabihin: ang isang estado na may malinaw na tinukoy na momentum (isang perpektong sinusoid sa espasyo) ay may napakawalang-katiyakang posisyon. Ang isang estado na may malinaw na tinukoy na posisyon (tulad ng isang Dirac delta distribution) ay may napakawalang-katiyakang momentum.

Mayroon pang ibang mga variable na nagpapakita ng ganitong hindi pagkakatugma. Halimbawa, ang spin ng isang particle ay maaaring magkaroon ng malinaw na tinukoy na proyeksyon sa isang axis, ngunit wala na tayong nalalaman tungkol sa proyeksyon sa isang ortogonal na axis. Halimbawa ang estado $|0\rangle \sim |\uparrow\rangle$ (para sa isang qubit o spin-1/2 na particle) ay may tiyak na proyeksyon sa kahabaan ng $z$ axis (ng 1 sa konteksto ng isang qubit, at ng $\hbar/2$ sa konteksto ng isang spin-1/2 na particle). Ngunit ang estadong ito ay maaaring isulat bilang isang superposisyon ng dalawang estado na ang bawat isa ay may malinaw na tinukoy na proyeksyon sa $x$ axis: $|0\rangle = \frac{1}{\sqrt{2}}(|+\rangle_x+|-\rangle_x)$ o katumbas nito $\begin{pmatrix} 1 \\ 0\end{pmatrix} = \frac{1}{\sqrt{2}}\left[\frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1\end{pmatrix}+\frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ -1\end{pmatrix}\right].$ Ang $|+\rangle_x$ ay may malinaw na tinukoy na proyeksyon sa $x$, tulad din ng $|-\rangle_x$. Kaya kung tinukoy natin ang proyeksyon ng isang estado sa kahabaan ng $x$ axis, hindi natin alam ang proyeksyon sa kahabaan ng $z$ axis. At kung tinukoy natin ang proyeksyon sa $z$ axis, hindi natin alam ang proyeksyon sa kahabaan ng $x$. May maliliit na pagkakaiba kapag tinalakay ito sa konteksto ng spin at ng mga qubit. Ngunit sa pangkalahatan, ang mga eigenstate ng mga Pauli matrix ay may kawili-wiling relasyon na maaari nating tuklasin.

Sa buong araling ito, eksperimentasyon nating susuriin ang ating intuisyon para sa kawalan ng katiyakan sa mga hindi tugmang variable na ito, at ibe-verify na ang mga relasyon ng kawalan ng katiyakan ay nananatili sa mga quantum computer ng IBM®.

Simpleng pagsusuri ng intuisyon

Sa unang eksperimentong ito at sa buong modyul, gagamit tayo ng isang balangkas para sa quantum computing na kilala bilang "Qiskit patterns", na nagpapahati ng mga daloy ng trabaho sa mga sumusunod na hakbang:

• Hakbang 1: I-map ang mga klasikal na input sa isang quantum na problema
• Hakbang 2: I-optimize ang problema para sa quantum execution
• Hakbang 3: I-execute gamit ang Qiskit Runtime Primitives
• Hakbang 4: Post-processing at klasikal na pagsusuri

Karaniwan naming susundin ang mga hakbang na ito, kahit hindi namin palaging tahasang ilalabel ang mga ito.

Magsimula tayo sa pag-load ng ilang kinakailangang pakete kasama ang Runtime primitives. Pipili rin tayo ng pinaka-hindi abala na quantum computer na available sa atin.

May code sa ibaba para sa pag-save ng iyong mga kredensyal sa unang paggamit. Siguraduhing burahin ang impormasyong ito mula sa notebook pagkatapos itong i-save sa iyong environment, para hindi aksidenteng maibahagi ang iyong mga kredensyal kapag ibinabahagi mo ang notebook. Tingnan ang I-set up ang iyong IBM Cloud account at I-initialize ang serbisyo sa isang hindi pinagkakatiwalaang environment para sa karagdagang gabay.

from numpy import pi

# 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 (
    Batch,
    SamplerV2 as Sampler,
    EstimatorV2 as Estimator,
)

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

ibm_sherbrooke

Kung maubusan ng available na quantum computing time ang isang estudyante sa panahon ng aralin, ang mga linya sa ibaba ay maaaring i-uncomment at gamitin para mag-set up ng simulator na bahagyang ginagaya ang gawi ng ingay ng quantum computer na pinili sa itaas.

# Import an estimator, this time from qiskit (we will import from Runtime for real hardware)
from qiskit_aer.primitives import SamplerV2, EstimatorV2
from qiskit_aer.noise import NoiseModel

# Generate the noise model from the backend properties
noise_model = NoiseModel.from_backend(backend)

noisy_sampler = SamplerV2(options={"backend_options": {"noise_model": noise_model}})
noisy_estimator = EstimatorV2(options={"backend_options": {"noise_model": noise_model}})

Maaaring maalala mo na ang isang eigenstate ng isang operator, Z, ay hindi isang eigenstate ng isa pang operator X. Maoobserbahan natin iyon ngayon, eksperimentalmente, sa pamamagitan ng paggawa ng mga sukat sa kahabaan ng $x$ at $z$ axes. Para sa sukat sa kahabaan ng $z$, ginagamit lang natin ang qc.measure(), dahil ang mga quantum computer ng IBM ay nakaayos upang sumukat sa kahabaan ng $z$. Ngunit para sumukat sa kahabaan ng $x$, kailangan nating i-rotate ang sistema upang epektibong ilipat ang $x$ axis pataas sa oryentasyon kung saan tayo sumusukat. Ito ay nagagawa sa pamamagitan ng isang Hadamard gate. Mayroong katulad na hakbang na kinakailangan para sa mga sukat sa kahabaan ng $y$. Ang mga kinakailangang hakbang ay nakolekta dito para sa kaginhawahan:

• Para sumukat sa kahabaan ng $z$: qc.measure()
• Para sumukat sa kahabaan ng $x$: qc.h() tapos qc.measure()
• Para sumukat sa kahabaan ng $y$: qc.sdg(), qc.h(), qc.s tapos qc.measure()

Hakbang 1: I-map ang mga klasikal na input sa isang quantum na problema

Sa kasong ito, ang hakbang ng mapping ay simpleng pagpapahayag ng mga sukat at pag-ikot na inilarawan sa itaas sa isang quantum circuit:

# Step 1: Map

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

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)

# Add a first measurement
qc.measure(qr, cr[0])
qc.barrier()

# Change basis so that measurements made on quantum computer which normally tell us about z,
# now tell us about x.
qc.h(qr)

# Add a second measurement
qc.measure(qr, cr[1])

qc.draw("mpl")

Hakbang 2: I-optimize ang problema para sa quantum execution

Kinukuha ng hakbang na ito ang mga operasyong gusto naming isagawa at inilalahad ang mga ito sa mga termino ng functionality ng isang tiyak na quantum computer. Ino-map din nito ang ating problema sa layout ng quantum computer.

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

Hakbang 3: I-execute gamit ang Qiskit Runtime primitives

Maaari nating gamitin ang sampler para mangolekta ng istatistika sa mga sukat. Itatayo natin ang Sampler primitive para tumakbo sa isang tunay na quantum computer gamit ang mode = backend. Mayroon pang ibang mga mode para sa iba pang mga daloy ng trabaho, at gagamitin natin ang isa sa ibaba. Gagamitin ang Sampler sa pamamagitan ng pagtawag sa run() method nito na may listahan ng "pubs" (Primitive Unified Blocs). Ang bawat pub ay naglalaman ng hanggang tatlong halaga na, magkasama, nagtatukoy ng isang yunit ng computation para makumpleto ng estimator: mga circuit, mga obserbasyon, mga parameter. Maaari ka ring magbigay ng listahan ng mga circuit, listahan ng mga obserbasyon, at listahan ng mga parameter. Para sa karagdagang impormasyon, basahin ang Pangkalahatang-ideya ng mga PUB.

Gusto nating tumakbo sa isang tunay na quantum computer, para nagsasagawa tayo ng tunay na eksperimento sa quantum physics. Kung maubusan mo ng iyong nakatalagang oras sa mga tunay na quantum computer, maaari mong i-comment out ang code sa ibaba para sa quantum computer, at i-uncomment ang code para sa pagpapatakbo sa isang simulator.

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

sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs)
res = job.result()

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

# Run the job on the Aer simulator with noise model from real backend

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

Hakbang 4: Post-processing

Ito ay isang espesyal na simpleng kaso ng post-processing, kung saan simpleng ini-visualize natin ang mga bilang.

Pansinin na ang Qiskit ay nag-oorder ng mga qubit, sukat, at iba pang mga bagay sa pamamagitan ng paglilista ng pinaka-mababang numero na item sa huli / sa kanan, isang kombensiyon na tinutukoy bilang "little-endian". Ibig sabihin, ang column sa ibaba na may label na "10" ay tumutukoy sa mga bilang kung saan ang unang sukat ay nagbunga ng "0", at ang pangalawang sukat ay nagbunga ng "1".

# Step 4: Post-process

from qiskit.visualization import plot_histogram

plot_histogram(counts)

Kung hindi ka naakit sa kombensyong ito, maaari mong gamitin ang marginal_counts para ma-visualize nang hiwalay ang mga resulta ng bawat sukat:

from qiskit.result import marginal_counts

plot_histogram(
    marginal_counts(counts, indices=[0]), title="Counts after first measurement"
)

plot_histogram(
    marginal_counts(counts, indices=[1]), title="Counts after second measurement"
)

Bilang default, ang mga estado sa Qiskit ay ini-initialize sa estado na $|0\rangle$. Kaya hindi nakakagulat na halos lahat ng unang sukat ay nagbunga ng $|0\rangle$. Ngunit pansinin, na halos pantay ang pagbabahagi sa pangalawang sukat (ang nagbibigay ng impormasyon tungkol sa mga proyeksyon ng estado sa $x$). Tila ang estadong nagbibigay sa atin ng napaka-predictable na resulta ng mga sukat sa kahabaan ng $z$ ay nagbibigay sa atin ng napaka-hindi-predictable na hanay ng mga resulta para sa mga sukat sa kahabaan ng $x$. Tuklasin natin ito.

Ano ang mangyayari kung gagawin natin ang mga sukat sa kabaligtarang pagkakasunod? Maaari tayong magsimula sa paggamit ng Hadamard gate para makakuha ng istatistika sa probabilidad ng $|0\rangle$ na masukat sa $|\pm\rangle_x$. Pagkatapos para sa pangalawang sukat, magbabalik tayo sa $z$ basis gamit ang pangalawang Hadamard gate.

# Step 1:

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)

# Change basis to measure along x.
qc.h(qr)
qc.measure(qr, cr[0])
qc.barrier()

# Change our basis back to z and make a second measurement
qc.h(qr)
qc.measure(qr, cr[1])

qc.draw("mpl")

# Step 2: Transpile the circuit for running on a quantum computer

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

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

sampler = Sampler(mode=backend)
pubs = [qc_isa]
job = sampler.run(pubs)
res = job.result()
counts = res[0].data.c.get_counts()

# Run the job on the Aer simulator with noise model from real backend
# job = noisy_sampler.run([qc_isa])
# res=job.result()
# counts=res[0].data.c.get_counts()

# Step 4: Post-process
from qiskit.visualization import plot_histogram

plot_histogram(counts)

Dito, tila mas kaunti na ang predictability! Dati, alam natin man lang kung ano ang magiging resulta ng unang sukat, ngayon ay mayroon tayong medyo pantay na pamamahagi sa lahat ng posibleng estado. Hindi masyadong mahirap makita kung bakit ito nangyari. Nagsimula tayo sa $|0\rangle$, na isang 50-50 na halo ng $|+\rangle_x$ at $|-\rangle_x$, ayon sa $|0\rangle=\frac{1}{\sqrt{2}}(|+\rangle_x+|-\rangle_x)$ Kaya malinaw na dapat mayroong pantay na probabilidad ng pagkuha ng estado na + o - (na naka-map sa 0 at 1 sa tsart) para sa unang sukat. Ang sukat sa kahabaan ng $x$ ay nagko-collapse ng estado sa alinman sa eigenstate na $|+\rangle_x$ o sa eigenstate na $|-\rangle_x$. Ang bawat isa sa mga estadong iyon ay isang 50-50 na halo ng $|0\rangle$ at $|1\rangle$, ayon sa $|+\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ $|-\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle-|1\rangle)$ Kaya kapag nasa eigenstate na ng $x$ ang sistema, malinaw na ang mga sukat sa kahabaan ng $z$ ay magbubunga ng parehong $|0\rangle$ at $|1\rangle$, at gagawin ito nang may halos pantay na probabilidad.

Kaya ang ating unang halimbawa ay nagpakita sa atin na ang ilang estado ay magkakaroon ng napaka-predictable na mga resulta ng ilang sukat, ngunit hindi-predictable na mga resulta para sa iba pang mga sukat. Ang kasalukuyang halimbawa ay nagpapakita sa atin na maaari tayong gumawa nang mas masahol pa. Mayroon mga estado na maaaring magbigay sa atin ng hindi-predictable na mga resulta para sa parehong sukat, kahit na ang ginagawa lang natin ay baguhin ang pagkakasunod ng mga sukat. Suriin natin kung gaano katiyak o hindi-tiyak ang isang dami para sa isang ibinigay na estado.

Pagkalkula ng kawalan ng katiyakan

Maaari nating sukatin ito gamit ang kawalan ng katiyakan, o variance. Ang "kawalan ng katiyakan" ay karaniwang tinukoy bilang square root ng "variance" ng isang distribusyon. Ibig sabihin, ang kawalan ng katiyakan para sa isang observable na $S$ ay tinutukoy ng $\Delta S$ at ibinibigay ng

$$\begin{aligned} (\Delta S)^2 & \equiv \langle (S - \langle S \rangle)^2 \rangle\\ (\Delta S)^2 & = \langle S^2 - 2 S \langle S \rangle +\langle S \rangle^2 \rangle\\ (\Delta S)^2 & = \langle S^2 \rangle - \langle S \rangle^2 \end{aligned}$$

Para sa kaso ng mga Pauli matrix, kung saan $S^2 = I$, nagiging ganito ito:

$$(\Delta S)^2 = 1 - \langle S \rangle^2$$

Ilapat natin ito sa isang kongkretong halimbawa. Magsimula tayo sa estado na $|\psi\rangle = |+\rangle_y = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ i \end{pmatrix},$ at tukuyin natin ang kawalan ng katiyakan ng observable na $X$ sa estadong iyon.

Suriin ang iyong pag-unawa

Kalkulahin ang kawalan ng katiyakan ng $X$ sa estado na $|+\rangle_y = |+i\rangle$, gamit ang kamay.

Answer

$$\Delta X =\sqrt{\langle+i| X^2 |+i\rangle - \langle+i| X |+i\rangle^2}$$

Sa ibinigay na estado, nagbubunga ito ng:

$$\begin{aligned} \Delta X & =\sqrt{\frac{1}{\sqrt{2}}\begin{pmatrix}1 & -i\end{pmatrix} \begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix} \begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix} \frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ i\end{pmatrix} - \left(\frac{1}{\sqrt{2}}\begin{pmatrix}1 & -i\end{pmatrix} \begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix} \frac{1}{\sqrt{2}}\begin{pmatrix}1 \\ i\end{pmatrix}\right)^2}\\ \Delta X & =\sqrt{\frac{1}{2}\begin{pmatrix}1 & -i\end{pmatrix} \begin{pmatrix}1 & 0 \\ 0 & 1\end{pmatrix} \begin{pmatrix}1 \\ i\end{pmatrix} - \left(\frac{1}{2}\begin{pmatrix}1 & -i\end{pmatrix} \begin{pmatrix}i \\ 1\end{pmatrix}\right)^2}\\ \Delta X & =\sqrt{\frac{1}{2}\begin{pmatrix}1 & -i\end{pmatrix} \begin{pmatrix}1 \\ i\end{pmatrix} - \left(\frac{1}{2}(0))\right)^2}\\ \Delta X & =\sqrt{\frac{1}{2}(2)} = 1 \end{aligned}$$

Maaari tayong lumikha ng arbitrary na paunang estado gamit ang qc.initialize(). Tandaan na ang syntax para sa imaginary unit dito ay $1j$.

# Step 1: Map the problem into a quantum circuit

from qiskit.quantum_info import SparsePauliOp
import numpy as np

obs = SparsePauliOp("X")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Initialize the state
qc.initialize([1, 1j] / np.sqrt(2))

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
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 = noisy_estimator.run([[qc_isa,obs_isa]])
# res=job.result()

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

print(res[0].data.evs)

-0.02408454165642664

Ayon sa ating equation sa itaas, $(\Delta X)^2 = 1 - \langle X \rangle^2 = 1-(0.0015...)^2 \rightarrow \Delta X = 0.999...$ Manatili tayo sa parehong estado, ngunit hanapin na natin ang expectation value ng $Z$ ngayon:

# Step 1: Map the problem into a quantum circuit

obs = SparsePauliOp("Z")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Initialize the state to |+>_y
qc.initialize([1, 1j] / np.sqrt(2))

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
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(pubs)
res = job.result()

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

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

print(res[0].data.evs)

0.04958271968581247

Magagawa nating gawin ang parehong matematika tulad ng dati, ngunit makikita natin na ang variance ay malapit na rin sa 1.0. Masasabing $\Delta X \Delta Z \approx 1.0$. Katotohanan, ito ay halos tama para sa estadong pinili natin. Ngunit kaya pa ba nating gumawa ng mas maganda? O mas masahol pa?

Alalahanin na may uncertainty relation sa pagitan ng posisyon sa isang direksyon, $x,$ at momentum sa parehong direksyon, $p_x.$ Para sa mga variable na iyon, ang pinakakilalang anyo ay malamang

$\Delta x \Delta p_x \geq \hbar/2$ Kung ito lang ang natatandaan natin, maaari tayong matukso na isipin na ang $\Delta X$ at $\Delta Z$ ay maaari ring magkaroon ng ganitong pundamental na limitasyon sa kawalan ng katiyakan. Marahil imposible para sa produkto $\Delta X \Delta Z$ na maabot ang zero? Subukan natin ang ibang estado at tingnan kung totoo ito. Sa pagkakataong ito, gagamitin natin ang $|\psi\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix}.$ Tingnan natin kung ano ang mangyayari. Tandaan na sa code sa ibaba, ang estimator ay maaaring tumanggap ng dalawang set ng mga circuit at observable sa iisang job submission.

# Step 1: Map the problem into a quantum circuit

obs1 = SparsePauliOp("X")
obs2 = SparsePauliOp("Z")

# Define registers

qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Initialize the state
qc.initialize([1, 1] / np.sqrt(2))

# Step 2: Transpile the circuit

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

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

with Batch(backend=backend) as batch:
    estimator = Estimator(mode=batch)
    pubs = [(qc_isa, obs1_isa), (qc_isa, obs2_isa)]
    job = estimator.run(pubs)
    res = job.result()
batch.close()

# Run the job on the Aer simulator with noise model from real backend

# job = noisy_estimator.run([[qc,obs1],[qc,obs2]])
# res=job.result()

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

print("The expectation value of the first observable is: ", res[0].data.evs)
print("The expectation value of the second observable is: ", res[1].data.evs)

The expectation value of the first observable is:  1.0011036174126302
The expectation value of the second observable is:  0.0029429797670141016

Ang expectation value ng $X$ ay dapat na malapit sa 1.0, ngunit hindi dapat lumampas sa 1.0. Huwag mag-alala kung ito ay lumampas ng kaunti sa 1.0. Ito ay maiuugnay sa mga salik tulad ng noise at/o readout error. Bagaman ito ay napakahalagang paksa, maaari nating balewalain ito sa ngayon.

Nakakuha tayo ng expectation value ng $X$ na napakalapit sa 1.0 (na tumutugma sa napakababang variance para sa $X$). Ginagawa nitong mababa ang produkto ng dalawang variance:

$$\Delta X \Delta Z = \sqrt{1-(0.9853)^2} \times \sqrt{1-(-0.00195)^2} = 0.171.$$

Bagaman hindi eksakto ang zero, ang halagang ito ay nagiging maliit kumpara sa mga eigenvalue ng mga Pauli operator ($\pm 1$). Baka naalala mo na ang uncertainty relation sa pagitan ng linear na posisyon at momentum ay maaaring isulat nang iba, gamit nang eksakto ang commutation relation sa pagitan ng mga operator na $x$ at $p_x$:

$$\Delta x \Delta p_x \geq \frac{1}{2}|\langle [x,p_x] \rangle|$$

kung saan

$$[x,p_x] = xp_x-p_xx$$

ang commutator ng $x$ at $p_x$.

Ito ang anyo na pinaka-madaling palawigin sa mga Pauli operator. Sa pangkalahatan, para sa dalawang operator na $A$ at $B$,

$$\Delta A \Delta B \geq \frac{1}{2}|\langle [A,B] \rangle|.$$

At sa kaso ng mga Pauli matrix na $X$ at $Z$, kailangan natin ang $[X,Z]$ para makalkula ang

$$\Delta X \Delta Z \geq \frac{1}{2}|\langle [X,Z] \rangle|.$$

Ipinakita natin ito dito, at iniiwan ang mga katulad na kalkulasyon sa mambabasa bilang ehersisyo:

$$[X,Z] = XZ-ZX = \begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix}\begin{pmatrix}1 & 0 \\ 0 & -1\end{pmatrix}-\begin{pmatrix}1 & 0 \\ 0 & -1\end{pmatrix}\begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix}$$ $$[X,Z] = \begin{pmatrix}0 & -1 \\ 1 & 0\end{pmatrix}-\begin{pmatrix}0 & 1 \\ -1 & 0\end{pmatrix} = 2\begin{pmatrix}0 & -1 \\ 1 & 0\end{pmatrix}$$

Ito ay isang ganap na katanggap-tanggap na sagot, ngunit sa isang hakbang pa, makikita natin

$$[X,Z] = -2i\begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}=-2iY$$

Ang ating uncertainty relation ay nagiging ganito

$$\Delta X \Delta Z \geq |\langle Y \rangle|.$$

Suriin ang iyong pag-unawa

Tukuyin ang $[X,Y]$ at $[Y,Z]$. Gamitin ito para isulat ang mga uncertainty relation sa pagitan ng $X$ at $Y$, at ng $Y$ at $Z$.

Answer

$$[X,Y] = XY-YX = \begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix}\begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}-\begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}\begin{pmatrix}0 & 1 \\ 1 & 0\end{pmatrix} = 2 \begin{pmatrix}i & 0 \\ 0 & -i\end{pmatrix}=2iZ$$$$[Y,Z] = YZ-ZY = \begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}\begin{pmatrix}1 & 0 \\ 0 & -1\end{pmatrix}-\begin{pmatrix}1 & 0 \\ 0 & -1\end{pmatrix}\begin{pmatrix}0 & -i \\ i & 0\end{pmatrix} = 2 \begin{pmatrix}0 & i \\ i & 0\end{pmatrix}=2iX$$

Pinagsama sa pangkalahatang uncertainty relation, mayroon tayong

$$\Delta X \Delta Y \geq |\langle Z \rangle|,$$$$\Delta Y \Delta Z \geq |\langle X \rangle|.$$

Suriin ang konsistensya

Bago tayo magpatuloy, suriin natin kung ito ay konsistente sa ating natuklasang nakaraan. Ginamit natin ang estado na $|\psi\rangle = \frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix}.$ At natuklasan natin na $\Delta X \Delta Z = 0.171.$ Ngayon alam na natin na ang produktong ito ay dapat na mas malaki o katumbas ng

$$|\langle Y \rangle|=\frac{1}{\sqrt{2}}\begin{pmatrix} 1 & 1 \end{pmatrix}\begin{pmatrix}0 & -i \\ i & 0\end{pmatrix}\frac{1}{\sqrt{2}}\begin{pmatrix} 1 \\ 1 \end{pmatrix}$$ $$|\langle Y \rangle| = \frac{1}{2}\begin{pmatrix} 1 & 1 \end{pmatrix}\begin{pmatrix} -i \\ i \end{pmatrix} = \frac{1}{2}(-i+i) = 0.$$

Kaya nga, $\Delta X \Delta Z = 0.171 \geq |\langle Y \rangle|=0$ Gamitin ang mga tanong sa ibaba para bumuo ng intuisyon para sa mga natuklasang ito:

Suriin ang iyong pag-unawa

Sagutin ang mga sumusunod na aytem bilang isang set:

(a) Anong mga estado ang inaasahan mong magkaroon ng zero uncertainty sa $X$?

(b) Anong mga estado ang inaasahan mong magkaroon ng zero uncertainty sa $Z$?

(c) Sa anong mga estado makakakuha ka ng zero expectation value na $\langle Y \rangle$?

(d) Ang mga sagot sa mga tanong sa itaas ba ay konsistente sa kaso na $\Delta X \Delta Z \geq |\langle Y \rangle|$?

(e) Magsulat ng code para tahasang suriin ito gamit ang estimator.

Answer

(a) Maaari tayong umasa na ang mga eigenstate ng operator na $X$ ay magbubunga ng zero uncertainty sa $X$. Katotohanan, gamit ang $|\psi\rangle = |+\rangle_x,$ mayroon tayong $\Delta X = \sqrt{1-\langle X \rangle^2} = \sqrt{1-1^2} = 0.$

(b) Maaari tayong umasa na ang mga eigenstate ng operator na $Z$ ay magbubunga ng zero uncertainty sa $Z$. Katotohanan, gamit ang $|\psi\rangle = |1\rangle,$ mayroon tayong $\Delta Z = \sqrt{1-\langle Z \rangle^2} = \sqrt{1-(-1)^2} = 0.$

(c) Inaasahan nating makita ang $\langle Y \rangle=0$ para sa anumang mga estado na, kapag sinukat, ay nagbubunga ng positibong proyeksyon sa $y$ axis nang kasing dalas ng negatibong proyeksyon. Kasama rito ang mga eigenstate ng $X$ at $Z$.

(d) Oo. Inaasahan ng isa ang napakamaliit na halaga para sa produkto ng mga kawalan ng katiyakan $\Delta X \Delta Z$ para sa mga eigenstate ng $X$ o $Z$: $\Delta X \Delta Z \approx 0.$ Maaari itong mangyari dahil inaasahan din nating $\langle Y \rangle=0$ para sa parehong mga estado. Kaya ang uncertainty relation ay maaaring matugunan.

(e) Ang code tulad ng sumusunod ay magbe-verify nito:

obs1 = SparsePauliOp.from_list(
    [("X", 1.000)]
)
obs2 = SparsePauliOp.from_list(
    [("Y", 1.000)]
)
obs3 = SparsePauliOp.from_list(
    [("Z", 1.000)]
)
qc = QuantumCircuit(1,1)
qc.ry(pi/2,0)

job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)
res=job.result()

Kung saan ang resulta ay nagbabalik ng lahat ng expectation value. Para makuha ang lahat ng expectation value at kalkulahin ang mga kawalan ng katiyakan, maaari nating gamitin ang:

xs=res[0].data.evs[0]
ys=abs(res[0].data.evs[1])
zs=res[0].data.evs[2]

import math
prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5

Sagutin ang mga sumusunod na aytem bilang isang set:

(a) Makapag-iisip ka ba ng estado kung saan magkakaroon ka ng malaking expectation value na $\langle Y \rangle$?

(b) Inaasahan mo ba na ang parehong estado ay magkakaroon ng malaki o maliit na kawalan ng katiyakan sa $X$?

(c) Inaasahan mo ba na ang parehong estado ay magkakaroon ng malaki o maliit na kawalan ng katiyakan sa $Z$?

(d) Ang mga sagot sa mga tanong sa itaas ba ay konsistente sa kaso na $\Delta X \Delta Z \geq |\langle Y \rangle|$?

(e) Magsulat ng code para tahasang suriin ito gamit ang estimator.

Answer

(a) Inaasahan nating makita ang $\langle Y \rangle\approx 1$ para sa eigenstate ng $Y$: $|+\rangle_y$.

(b) Maaari tayong umasa na ang $X$ ay magkaroon ng malaking kawalan ng katiyakan sa estado na $|+\rangle_y,$ dahil ang pagsukat ng $X$ sa estadong iyon ay magbubunga ng positibo at negatibong resulta nang may pantay na dalas/posibilidad.

(c) Maaari tayong umasa na ang $Z$ ay magkaroon ng malaking kawalan ng katiyakan sa estado na $|+\rangle_y,$ dahil ang pagsukat ng $Z$ sa estadong iyon ay magbubunga ng positibo at negatibong resulta nang may pantay na dalas/posibilidad.

(d) Oo. Inaasahan ng isa ang malaking halaga para sa produkto ng mga kawalan ng katiyakan $\Delta X \Delta Z$ para sa mga eigenstate ng $Y,$ at para sa $|+\rangle_y,$ partikular. Inaasahan din nating $\langle Y \rangle\approx 1$ para sa parehong estado. Kaya ang $\langle Y \rangle$ at $\Delta X \Delta Z$ ay parehong medyo malaki sa estadong ito, at makatwirang inaasahan na ang uncertainty relation ay maaaring muli na matugunan.

(e) Ang code tulad ng sumusunod ay magbe-verify nito:

obs1 = SparsePauliOp.from_list(
    [("X", 1.000)]
)
obs2 = SparsePauliOp.from_list(
    [("Y", 1.000)]
)
obs3 = SparsePauliOp.from_list(
    [("Z", 1.000)]
)
qc = QuantumCircuit(1,1)
qc.rx(-pi/2,0)

job = estimator.run([(qc, [[obs1], [obs2], [obs3]])], precision=0.001)
res=job.result()

Kung saan ang resulta ay nagbabalik ng lahat ng expectation value. Para makuha ang lahat ng expectation value at kalkulahin ang mga kawalan ng katiyakan, maaari nating gamitin ang:

xs=res[0].data.evs[0]
ys=abs(res[0].data.evs[1])
zs=res[0].data.evs[2]

import math
prodxz=((1-xs[i]*xs[i])**0.5)*(1-zs[i]*zs[i])**0.5

Pagsubok ng mga uncertainty relation

Ang pagsubok sa itaas ay nagpakita lamang ng bisa ng uncertainty relation para sa isang pagpipilian ng state vector na $|\psi\rangle = |+\rangle_x$. Para makumbinse ang ating sarili na ito ay karaniwang konsistente sa eksperimento, dapat tayong magsagawa ng mga katulad na kalkulasyon gamit ang estimator para sa maraming pagpipilian ng state vector. Magsimula tayo sa pamamagitan ng pag-ikot ng ating state vector palayo sa $z$ axis, gamit ang isang RY gate para makagawa ng iba't ibang paunang estado gamit ang parameter na $\theta$.

# The calculation below uses approximately 3-4 minutes of QPU time.
# Step 1: Map the problem into a quantum circuit

from qiskit.circuit import Parameter
import numpy as np

# Specify observables
obs1 = SparsePauliOp("X")
obs2 = SparsePauliOp("Y")
obs3 = SparsePauliOp("Z")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Rotate away from |0>
theta = Parameter("θ")
qc.ry(theta, 0)

params = np.linspace(0, 2, num=21)

# Step 2: Transpile the circuit

pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)
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

with Batch(backend=backend) as batch:
    estimator = Estimator(mode=batch)
    pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]
    job = estimator.run(pubs, precision=0.01)
    res = job.result()

batch.close()

# Run the job on the Aer simulator with noise model from real backend

# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])
# res=job.result()

# Step 4: Post-processing and classical analysis.
xs = res[0].data.evs[0]
ys = abs(res[0].data.evs[1])
zs = res[0].data.evs[2]

# Calculate uncertainties

delx = []
delz = []
prodxz = []
for i in range(len(xs)):
    delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)
    delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)
    prodxz.append(delx[i] * delz[i])

# Here we can plot the results from this simulation.
import matplotlib.pyplot as plt

plt.plot(params, delx, label=r"$\Delta$ X")
plt.plot(params, ys, label=r"$\langle$ Y $\rangle$")
plt.plot(params, delz, label=r"$\Delta$ Z")
plt.plot(params, prodxz, label=r"$\Delta$X $\Delta$Z")
plt.xlabel(r"$\theta$")
plt.ylabel("Expectation/Uncertainty Values")
plt.legend()
plt.show()

Pansinin na ang pulang kurba $(\Delta X \Delta Z)$ ay palaging mas malaki kaysa sa orange na kurba $\langle Y \rangle.$ Minsan ang produkto ng kawalan ng katiyakan ay bumababa at medyo malapit sa limitasyon, at sa ibang pagkakataon ay tumataas at mas malayo sa limitasyon, ngunit palagi itong sumusunod sa uncertainty relation.

Siyempre, maaaring hindi ito ang pinakamainam na pagsubok ng uncertainty relation, dahil ang ating limitasyon na $\langle Y \rangle$ ay palaging napakalapit sa zero. Gamitin natin ang isang quantum na estado na may mas malaking proyeksyon sa mga eigenstate ng $Y$. Partikular, mag-iikot pa rin tayo ng $|0\rangle$ pababa mula sa $z$ axis nang iba't ibang anggulo, ngunit ngayon ay iikutin din natin ang resultang estado sa paligid ng $z$ nang ilang anggulo, marahil $\pi/4$, at tingnan kung ano ang mangyayari.

# The calculation below uses approximately 3-4 minutes of QPU time.
from qiskit.circuit import Parameter
import numpy as np

# Step 1: Map the problem to a quantum circuit

# Specify observables
obs1 = SparsePauliOp("X")
obs2 = SparsePauliOp("Y")
obs3 = SparsePauliOp("Z")

# Define registers
qr = QuantumRegister(1, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)

# Rotate away from |0> along one plane, and then along a transverse direction.
theta = Parameter("θ")
qc.ry(theta, 0)
qc.rz(pi / 4, 0)

params = np.linspace(0, 2, num=21)

# Step 2: Transpile the circuit

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

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

with Batch(backend=backend) as batch:
    estimator = Estimator(mode=batch)
    pubs = [(qc_isa, [[obs1_isa], [obs2_isa], [obs3_isa]], [params])]
    job = estimator.run(pubs, precision=0.01)
    res = job.result()

batch.close()

# Run the job on the Aer simulator with noise model from real backend

# job = noisy_estimator.run([(qc, [[obs1], [obs2], [obs3]], [params])])
# res=job.result()

# Step 4: Post-processing and classical analysis.
xs = res[0].data.evs[0]
ys = abs(res[0].data.evs[1])
zs = res[0].data.evs[2]

# Calculate uncertainties

delx = []
delz = []
prodxz = []
for i in range(len(xs)):
    delx.append(abs((1 - xs[i] * xs[i])) ** 0.5)
    delz.append(abs((1 - zs[i] * zs[i])) ** 0.5)
    prodxz.append(delx[i] * delz[i])

# Here we can plot the results from this simulation.
import matplotlib.pyplot as plt

plt.plot(params, delx, label=r"$\Delta$ X")
plt.plot(params, ys, label=r"$\langle$ Y $\rangle$")
plt.plot(params, delz, label=r"$\Delta$ Z")
plt.plot(params, prodxz, label=r"$\Delta$X $\Delta$Z")
plt.xlabel(r"$\theta$")
plt.ylabel("Expectation/Uncertainty Values")
plt.legend()
plt.show()

Ngayon makikita natin na ang limitasyon sa kawalan ng katiyakan $(\Delta X \Delta Z)$ ay sinusubukan na! Ang pulang kurba ay mas malapit na sa orange na kurba kaysa dati. Sa katunayan, sa kawalan ng noise, ang uncertainty relation ay magiging eksakto na siksik ($(\Delta X \Delta Z) = \langle Y \rangle$) sa isang punto. Sa presensya ng noise at readout error, hindi dapat ikagulat kung minsan ay nagbubunga ng $(\Delta X \Delta Z)$ na bahagyang mas malaki kaysa sa $\langle Y \rangle$ ang isang run. Hindi ito tunay na paglabag sa kawalan ng katiyakan; ito ay isang artifact lamang ng hindi-zero na error.

Suriin ang iyong pag-unawa

Ipaliwanag kung paano mo ito itutulak sa ganap na limitasyon, na ginagawang pinaka-malaki ang $\langle Y \rangle$.

Answer

Ang code sa kasalukuyan ay may mga linya na nag-iikot ng default na paunang estado na $|0\rangle$, pababa mula sa $z$ axis nang ilang parametrisadong anggulo na $\theta$ at pagkatapos ay sa paligid ng $z$ axis nang isang anggulo na $\pi/4,$ na nag-iikot ng state vector bahagi ng daan patungo sa $y$ axis.

qc.ry(theta,0)

qc.rz(pi/4,0)

Maaari nating baguhin ang pag-ikot sa paligid ng $z$ mula $\pi/4$ patungong $\pi/2$, pag-iikot nang lahat ng paraan hanggang sa isang eigenstate ng $Y$:

qc.ry(theta,0)

qc.rz(pi/2,0)

Walang ibang mga pagbabago ang kailangan.

Baguhin ang code o kopyahin ito at ipatupad ang pagsusuring iyon ng uncertainty relation na may expectation value ng Y na nami-maximize. Nananatili ba ang uncertainty relation?

Answer

Gagamitin natin ang eksakto ang code mula sa halimbawa sa itaas, na may

qc.rz(pi/2,0)

na pinapalitan ang

qc.rz(pi/4,0).

Ang resultang figure ay dapat magmukhang katulad ng nasa ibaba, at oo, ang prinsipyo ng kawalan ng katiyakan ay dapat na may bisa pa rin.

Baguhin ang code sa itaas para gumawa ng katulad na larawan, na nagpapakita na mula sa mga sukat sa quantum computer ang produkto na $\Delta X \Delta Y$ ay kumikilos nang dapat. Pumili ng anumang set ng mga estado.

Answer

Gagamitin natin ang eksakto ang code mula sa halimbawa sa itaas, at sa katunayan maaari nating gamitin ang parehong mga resulta mula sa itaas, gamit lamang ang mga expectation value para kalkulahin ang iba't ibang mga kawalan ng katiyakan. Halimbawa, maaari nating gamitin ang

xs=res[0].data.evs[0]
ys=res[0].data.evs[1]
zs=abs(res[0].data.evs[2])
import math
delx = []
dely = []
prodxy=[]
for i in range(len(xs)):
    delx.append((1-xs[i]*xs[i])**0.5)
    dely.append((1-ys[i]*ys[i])**0.5)
    prodxy.append(((1-xs[i]*xs[i])**0.5)*(1-ys[i]*ys[i])**0.5)

at maaari tayong mag-plot ng

import matplotlib.pyplot as plt
plt.plot(params, delx, label=r'$\Delta$ X')
plt.plot(params, dely, label=r'$\langle$ Y $\rangle$')
plt.plot(params, zs, label=r'$\Delta$ Z')
plt.plot(params, prodxy, label=r'$\Delta$X $\Delta$Z')
plt.xlabel(r'$\theta$')
plt.ylabel('Expectation/Uncertainty Values')
plt.legend()
plt.show()

Hamon: Magsulat ng code para mag-scan sa maraming halaga ng $\phi$, tulad ng pag-scan natin sa maraming halaga ng $\theta$, at gumawa ng 3-D na plot na nagpapakita na ang uncertainty relation ay hindi kailanman nilalabag. Pumili ng anumang mga observable.

Mga Tanong

Ang mga guro ay maaaring humiling ng mga bersyon ng mga notebook na ito na may mga susi sa sagot at gabay sa paglalagay sa karaniwang mga kurikulum sa pamamagitan ng pagsagot sa mabilis na survey na ito kung paano ginagamit ang mga notebook.

Mga kritikal na konsepto:

• May mga uncertainty relation sa pagitan ng maraming set ng mga pisikal na observable, kabilang ang posisyon at linear na momentum, at mga bahagi ng spin.
• Ang mga Pauli matrix ay hindi nagko-commute. Ito ay isang matematikong repleksyon ng katotohanang hindi lahat ng mga bahagi ng spin ay maaaring sabay na malaman/matukoy.
• Ang quantum computing ay gumagamit nang malawak ng mga Pauli operator/matrix, kaya kapaki-pakinabang na malaman ang uncertainty relation para sa mga Pauli operator, pati na rin ang malapit na kaugnay na mga spin operator.
• Ang pangkalahatang formula para sa kawalan ng katiyakan ng dalawang operator na $A$ at $B$ ay $\Delta A \Delta B \geq \frac{1}{2}|\langle [A,B] \rangle|.$
• Ang isang eigenstate na $|a\rangle$ ng ilang operator na $A$ ay nagbubunga ng zero uncertainty sa pisikal na observable na nauugnay sa operator na iyon. Kahit eksperimentalmente, $\Delta A \approx 0.$
• Ang isang eigenstate na $|a\rangle$ ng ilang operator na $A$ ay magbubunga ng mas malaking kawalan ng katiyakan para sa isang operator na $B$ na hindi nagko-commute sa $A$.
• Ang mga eksperimental na resulta gamit ang isang tunay na quantum computer ay nagpapatibay ng intuisyon na nakukuha natin mula sa mga matrix na representasyon ng mga pisikal na operator.

Mga Tanong na T/H (Tama/Huwad):

1. T/H Maaaring sabay na sukatin ang $X$ at $Y$, ngunit hindi ang $Z$.
2. T/H Maaaring sabay na sukatin ang $X$ at $Z$, ngunit hindi ang $Y$.
3. T/H Hindi nagko-commute ang mga linear na posisyon at linear na momentum operator.
4. T/H Ang mga IBM quantum computer ay sumusukat kasama ang $Z$ bilang default, kaya ang isang pag-ikot ay dapat gawin para sumakit kasama ang anumang ibang direksyon.
5. T/H Ang circuit sa ibaba ay epektibong sumusukat ng $Z$ at pagkatapos $X$.

Mga Tanong na MC (Maramihang Pagpipilian):

1. Ang diagram sa ibaba ay nagpapakita ng alin sa mga sumusunod na uncertainty relation?

   • a. $\Delta X \Delta Y \geq |\langle Z \rangle|$
   • b. $\Delta Y \Delta Z \geq |\langle X \rangle|$
   • c. $\Delta Z \Delta X \geq |\langle Y \rangle|$
   • d. Wala sa itaas

2. Alin sa mga sumusunod ang karaniwang pagkakasunod-sunod para magsagawa ng sukat kasama ang $x$?

   • a. qc.measure() lamang
   • b. qc.h() pagkatapos qc.measure()
   • c. qc.h(), qc.h() pagkatapos qc.measure()
   • d. qc.h(), qc.s, qc.h() pagkatapos qc.measure()
   • e. qc.sdg(), qc.h(), qc.s pagkatapos qc.measure()
   • f. qc.sdg(), qc.h(), qc.s, qc.h() pagkatapos qc.measure()

3. Alin sa mga sumusunod na estado ang nagbubunga ng pinakamalaking expectation value na $\langle X \rangle$?

   • a. $|+\rangle_x$
   • b. $|-\rangle_x$
   • c. $|+\rangle_y$ na tinatawag ding $|+i\rangle$
   • d. $|-\rangle_y$ na tinatawag ding $|-i\rangle$
   • e. $|0\rangle$ na tinatawag ding $|\uparrow\rangle$
   • f. $|1\rangle$ na tinatawag ding $|\downarrow\rangle$

4. Alin sa mga sumusunod na estado ang nagbubunga ng pinakamalaking kawalan ng katiyakan na $\Delta X$?

   • a. $|+\rangle_x$
   • b. $|+\rangle_y$ na tinatawag ding $|+i\rangle$
   • c. $|0\rangle$ na tinatawag ding $|\uparrow\rangle$
   • d. Magkapantay ang a at b
   • e. Magkapantay ang b at c
   • f. Magkapantay ang a, b, at c

Mga Tanong para sa Talakayan:

1. Ang konseptong ito ng kawalan ng katiyakan ba ay nagkokontra sa anumang paraan sa ideya ng spin bilang isang vector arrow sa Cartesian space? Paano naman sa Bloch sphere?

2. Ipagpalagay na nakahanay ka ng isang instrument sa pagsukat sa isang direksyon na nasa pagitan ng $x$ at $y$ axis. Ano ang mangyayari? Maaari ka bang magsagawa ng sukat sa direksyong ito? Paano ito nauugnay sa kawalan ng katiyakan sa $X$ at $Y$?

3. Anong mga karagdagang eksperimento ang nais mong gawin para makumbinse ang iyong sarili sa mga resultang nakuha rito?