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 — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"matplotlib": "matplotlib", "numpy": "numpy", "qiskit": "qiskit", "qiskit_aer": "qiskit-aer", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

# 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 uncertainty principle, kahit sa labas ng iyong mga kurso sa physics. Isang karaniwang kolokyal na paglalahad ng uncertainty ay "Sa pagtingin sa isang bagay, naiimpluwensyahan mo ito." Iyon ay tama. Ngunit ang mas physical na paraan ng paglalarawan sa uncertainty ay may ilang physical observable na hindi tugma sa isa't isa na pumipigil sa dalawa nito na malaman nang sabay sa arbitrary na katumpakan. Maraming estudyante ang unang nakakaengkwentro sa pares ng hindi tugmang variables na $x$ at $p_x$, ibig sabihin ang posisyon sa kahabaan ng isang axis na tinatawag na $x$-axis, at ang linear momentum sa kahabaan ng direksyon na iyon, ayon sa pagkakabanggit. Para sa mga variable na iyon ang hadlang sa uncertainty ay isinusulat bilang $\Delta x \Delta p_x \geq \frac{\hbar}{2}.$ Dito, ang $\Delta x$ ay tinatawag na "uncertainty sa $x$", na may parehong depinisyon gaya ng standard deviation sa statistics, at maaaring tukuyin bilang $\Delta x = \sqrt{\langle x^2 \rangle - \langle x \rangle^2}.$ Ang $\Delta p_x$ ay tinutukoy sa parehong paraan. Dito, hindi natin i-de-derive ang uncertainty relation na ito; ituturo natin na ito ay tugma sa ating pag-unawa sa classical waves. Ibig sabihin, ang alon na may talagang isang perpektong frequency na $f$ at wavelength na $\lambda$ ay magpapatuloy nang walang hanggan bilang isang perpektong sinusoid. Sa quantum mechanically, ito ay katumbas ng pagkakaalam nang perpekto sa momentum ayon sa hypothesis ni de Broglie: $\lambda = h/p$. Ngunit upang malaman kung $saan$ matatagpuan ang isang wave-like particle, ang alon na naglalarawan nito ay dapat maging mas matalas na peaked sa espasyo, tulad ng isang napakakitid na Gaussian, halimbawa. Alam natin na maaari nating ipahayag ang anumang tuloy-tuloy na function, kabilang ang ganoong matatalim na peaked wave functions, bilang isang Fourier series ng mga sinusoidal functions na may iba't ibang wavelength. Ngunit habang nagiging mas matalim ang peak ng wave function (at mas nalalaman ang posisyon), kakailanganin natin ng mas maraming termino sa Fourier series, ibig sabihin ay pinaghalong maraming wavelength (at sa gayon, quantum mechanically, mas maraming halaga ng momentum).

Sa mas simpleng pagsasabi: ang isang state na may malinaw na tinukoy na momentum (isang perpektong sinusoid sa espasyo) ay may napakawalang katiyakang posisyon. Ang isang state na may malinaw na tinukoy na posisyon (tulad ng isang Dirac delta distribution) ay may napakawalang katiyakang momentum.

May iba pang mga variable na nagpapakita ng ganitong hindi pagkakatugma. Halimbawa, ang spin ng isang particle ay maaaring may malinaw na tinukoy na projection sa kahabaan ng isang axis, ngunit wala tayong alam tungkol sa project sa isang orthogonal axis. Halimbawa ang state na $|0\rangle \sim |\uparrow\rangle$ (para sa isang qubit o spin-1/2 particle) ay may tiyak na projection sa kahabaan ng $z$ axis (ng 1 sa konteksto ng isang qubit, at ng $\hbar/2$ sa konteksto ng isang spin-1/2 particle). Ngunit ang state na ito ay maaaring isulat bilang superposition ng dalawang state na bawat isa ay may malinaw na tinukoy na projection sa $x$ axis: $|0\rangle = \frac{1}{\sqrt{2}}(|+\rangle_x+|-\rangle_x)$ o katumbas $\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 projection sa $x$, tulad din ng $|-\rangle_x$. Kaya kung tutukuyin natin ang projection ng isang state sa kahabaan ng $x$ axis, hindi natin alam ang projection sa kahabaan ng $z$ axis. At kung tutukuyin natin ang projection sa $z$ axis, hindi natin alam ang projection sa kahabaan ng $x$. May mga maliliit na pagkakaiba kapag pinag-uusapan ito sa konteksto ng spin at ng mga qubit. Ngunit sa pangkalahatan, ang mga eigenstate ng Pauli matrices ay may kawili-wiling relasyon na maaari nating tuklasin. Sa buong lesson na ito, susuriin natin nang eksperimental ang ating intuwisyon para sa uncertainty sa mga hindi tugmang variable na ito, at beberipikahin na ang mga uncertainty relation ay totoo sa mga IBM® quantum computer.

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 IBM Quantum 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 IBM Quantum Compute 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 IBM Quantum 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 ipinakita sa atin ng ating unang halimbawa na ang ilang estado ay may napaka-predictable na resulta para sa ilang sukat, ngunit hindi predictable na resulta para sa iba pang sukat. Ipinapakita sa atin ng kasalukuyang halimbawa na maaari tayong magkaroon ng mas masahol pa dito. May mga estado na makapagbibigay sa atin ng hindi predictable na resulta para sa parehong sukat, kahit na ang tanging ginawa lang natin ay palitan ang pagkakasunod-sunod ng mga sukat. Suriin natin kung gaano katiyak o hindi katiyak ang isang dami para sa isang partikular 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 uncertainty ng $X$ sa state na $|+\rangle_y = |+i\rangle$, sa kamay.

Answer

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

In the given state, this yields:

$$\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 gumawa ng arbitrary na initial state 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 state, ngunit hanapin 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

Maaari nating gawin ang parehong matematika gaya ng dati, ngunit makikita natin na ang variance ay muling napakalapit sa 1.0. Mahihinuha natin na $\Delta X \Delta Z \approx 1.0$. Sa katunayan, tinatayang tama ito para sa estadong pinili natin. Pero kaya ba nating mapababa pa ito? O mapalaki?

Tandaan na mayroong uncertainty relation sa pagitan ng posisyon sa kahabaan ng isang direksyon, $x,$ at momentum sa kahabaan ng parehong direksyon, $p_x.$ Para sa mga variable na iyon, ngunit malamang na pinakapamilyar na anyo ay $\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 ganoong pundamental na limitasyon sa uncertainty. Marahil imposible para sa produkto na $\Delta X \Delta Z$ na maabot ang zero? Subukan natin ang isa pang state at tingnan kung ito ay totoo. 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 parehong 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: Sumulat ng code para i-scan ang maraming halaga ng $\phi$, katulad ng pag-scan natin sa maraming halaga ng $\theta$, at gumawa ng 3-D plot na nagpapakita na hindi kailanman nilalabag ang uncertainty relation. Pumili ng anumang observable na gusto mo.

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?