Ang iyong unang quantum experiment

Panimula

Sa sumusunod na video, gagabayan ka ni Olivia Lanes sa nilalaman ng aralin na ito. Bilang alternatibo, maaari mong buksan ang YouTube video para sa araling ito sa hiwalay na window.

Sa ngayon, napatakbo mo na ang iyong unang quantum circuit at natutuhan ang mga pangunahing kaalaman ng quantum computing: kung paano kinakatawan ang mga quantum state, kung paano kumikilos ang mga gate sa mga state na iyon, at kung paano kasangkot ang mga quantum feature tulad ng superposition at entanglement. Oras na para ilagay ang lahat ng ito sa praktika at resolbahin ang iyong unang problema sa isang quantum computer.

Tuklasin natin ang mas malawak na landscape ng mga problema na angkop sa quantum sa isang susunod na aralin. Sa ngayon, magtutuon tayo sa isang problema sa domain ng nature simulation: paggamit ng quantum computer bilang isang mas malinis, mas kontrolableng kahalili ng isang natural na quantum system. Sa katunayan, ito ang unang aplikasyon na inakala ni Richard Feynman para sa mga quantum computer noong 1980s. Tulad ng kanyang sinabing kilala: "Nature isn't classical, dammit, and if you want to make a simulation of nature, you'd better make it quantum mechanical..."

Sa araling ito, susundin natin ang prinsipyong iyon upang i-simulate ang pakikipag-ugnayan sa pagitan ng dalawang spin, na maaari mong isipin bilang maliliit na magnet. Depende sa sign ng kanilang pakikipag-ugnayan, maaari nilang gusto ang mag-align at ituro sa parehong direksyon, o anti-align at ituro sa magkasalungat na direksyon. Magtutuon tayo sa huli dahil kadalasan ito ay humahantong sa mas kawili-wili — at mas mahirap — na gawi. Kapag naunawaan na natin ang maliit na two-qubit na sistemang ito, ipapakita natin kung paano nagsa-scale up ang parehong mga ideya, na nagbibigay-daan sa mga quantum computer na samantalahin ang kanilang exponential scaling kapag nag-simulate ng malalaking spin system.

Dalawang nakikipag-ugnayang magnet

Para sa problemang ito, gagamit tayo ng dalawang qubit, isa para sa bawat spin sa ating modelo. Ang bawat spin ay maaaring ituro nang pataas (qubit state $|0\rangle$), pababa (qubit state $|1\rangle$), o sa isang superposition ng dalawang state.

Kung ang mga spin ay may antiferromagnetic na pakikipag-ugnayan, ibig sabihin nito ay gusto nilang mag-anti-align, kaya kapag ang isa ay pataas, ang isa pa ay gusto pababa, at vice-versa.

Ngayon ipagpalagay na mayroon ding magnetic field na nakaturo mula kaliwa hanggang kanan sa ating sistema. Dahil ang field na ito ay nakaturo sa kabuuan ng karaniwang pataas-pababa na direksyon ng mga spin, ito ay tinatawag na transverse field. Ang field na ito ay maaaring mag-flip ng mga spin, na nagdudulot ng pinakamababang energy configuration na isang partikular na superposition ng mga pataas-at-pababa na ayos ng spin kaysa sa anumang solong tiyak na pattern ng spin.

Maaari nating ilarawan ang lahat ng epektong ito gamit ang isang mathematical na object na tinatawag na Hamiltonian. Sinasabi sa atin ng Hamiltonian ang enerhiya ng sistema para sa isang ibinigay na ayos ng mga spin:

$$H = J Z_1 Z_0 + h_x (X_1 + X_0)$$

kung saan ang $J$ ay isang coefficient na kumokontrol sa lakas ng pakikipag-ugnayan sa pagitan ng mga spin at ang $h_x$ ay isang coefficient para sa lakas ng external magnetic field. Ang $Z_1 Z_0$ ay nagbibigay gantimpala o parusa sa mga spin depende kung sila ay aligned o anti-aligned, at ang $X_0$ at $X_1$ ay kumakatawan sa spin-flipping na epekto ng magnetic field.

Sa physics, ang mga sistema ay tend na mag-settle sa state na may pinakamababang posibleng enerhiya, na tinatawag na ground state. Ang paghahanap ng pinakamababang-energy na state na ito ay isang karaniwang problema, ngunit nangangailangan ito ng mga optimization technique na lampas sa saklaw ng araling ito.

Sa halip, magtatanong tayo ng mas simple: Kung ihahanda natin ang mga spin sa isang partikular na state, ano ang enerhiya ng state na iyon?

Para sagutin ito, gagawin natin ang sumusunod:

1. Ihanda ang mga spin sa isang state ng ating pagpili
2. Sukatin ang enerhiya ng state na iyon gamit ang Hamiltonian sa itaas

Ito ay eksakto ang uri ng kalkulasyon na lumalabas sa loob ng malalaking quantum algorithm, tulad ng mga variational algorithm, na maaari mong tuklasin sa mga susunod na kurso.

Implementasyon sa Qiskit

Bago sumabak sa pagsusulat ng code, kailangan natin ng kaunting konteksto. Kapag nagpapatakbo tayo ng quantum circuit, palagi tayong nagtatapos sa pamamagitan ng pagsukat ng mga qubit. Ngunit mayroong dalawang magkaibang uri ng tanong na maaaring gusto nating itanong tungkol sa resulta ng pagsukat na iyon: Minsan, gusto lang nating malaman kung ano ang state ng qubit. Sa ibang pagkakataon, gusto nating malaman, na binigyan ng quantum state, ano ang halaga ng isang pisikal na dami, tulad ng enerhiya?

Sa Qiskit, ang dalawang uri ng tanong na ito ay hinahawakan ng dalawang magkaibang tool, na tinatawag na primitives.

Ang Sampler ay sumasagot sa unang uri ng tanong. Pinapatakbo nito ang circuit nang maraming beses at sinasabi sa atin kung gaano kadalas natin sinusukat ang bawat posibleng resulta, tulad ng 00, 01, 10, o 11. Ang resulta ay isang histogram na nagpapakita ng probability ng bawat measurement outcome.

Ang Estimator ay sumasagot sa pangalawang uri ng tanong. Sa halip na bigyan tayo ng histogram, pinagsasama nito ang maraming sukat sa likod ng eksena upang kalkulahin ang isang solong numero, tulad ng enerhiya ng state ayon sa isang Hamiltonian na ibibigay natin.

Upang matulungan kang maunawaan kung kailan at bakit gagamitin ang bawat isa sa mga tool na ito, lalakaran natin ang dalawang kumpletong workflow (tinatawag na "Qiskit patterns") na inilapat sa parehong two-qubit na sistema.

Qiskit patterns workflow

Ang Qiskit patterns workflow ay isang pangkalahatang balangkas na ginagamit natin upang resolbahin ang mga quantum problema sa Qiskit. Binabali nito ang isang quantum computing task sa apat na hakbang:

1. I-map ang problema sa isang modelo na maaaring kinatawan ng mga quantum circuit
2. I-optimize ang circuit para patakbuhin sa isang partikular na backend
3. I-execute ang na-optimize na circuit sa napiling backend
4. Post-process ang raw measurement data

Eksperimento 1: Gamitin ang Sampler para sukatin ang state

I-map

Sa pangkalahatan, ang hakbang ng mapping ay kung saan natin nalalaman kung paano kikatawan ang isang real-world na problema sa mga qubit, operator, at sukat. Sa maraming aplikasyon, ito ang pinaka-kumplikado at pinaka-sangkot na bahagi ng workflow — kahit ang mga simpleng tanong, tulad ng "ano ang kinakatawan ng bawat qubit?" ay hindi laging may direktang sagot.

Sa eksperimentong ito, gayunpaman, ang mapping ay sadyang simple. Ang bawat pisikal na degree of freedom ay direktang nagmamapa sa isang solong qubit. Dahil sa one-to-one na suliraning ito, ang hakbang ng mapping ay nagiging pagpili ng quantum state na gusto nating ihanda at pagsulat ng circuit na naghahanda at sumusukat sa state na iyon.

Dito, maghahanda tayo ng entangled Bell state, katulad ng ginawa natin sa pinaka-unang aralin ng kursong ito:

$$\vert\Psi\rangle = \frac{1}{\sqrt{2}}(\vert 10\rangle - \vert 01\rangle)$$

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

# Import Qiskit primitives
from qiskit import QuantumCircuit

# Make state
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.x(1)
qc.z(0)

# Measure state
qc.measure_all()

# Draw circuit
qc.draw("mpl")

I-optimize

Bago patakbuhin ang ating circuit sa isang quantum computer (o isang simulator kung naubos mo na ang iyong libreng oras sa mga tunay na quantum computer para sa buwan), kailangan nating ihanda ito para sa execution. Ang hakbang na ito ay tinatawag na optimization. (Tandaan: ang paggamit ng salitang "optimization" na ito ay maaaring nakalilito. Sa quantum computing, ang mga problema sa optimization ay tumutukoy sa isang partikular na klase ng mga problema. Dito, ginagamit natin ang optimization upang ilarawan ang isang kinakailangang hakbang sa paghahanda na dumadaan ang bawat quantum circuit bago ito mapatakbo nang mahusay sa hardware.)

Sa panahon ng optimization:

1. Pinipili natin ang backend — alinman sa isang tunay na quantum computer o isang simulator.
2. Iniaatas natin ang mga qubit ng ating circuit sa mga pisikal na qubit sa device.
3. Sinusulat ulit natin ang circuit gamit lamang ang mga gate na kaya talagang gawin ng quantum computer.
4. Opsyonal na nag-iimplementa ng mga error mitigation at suppression technique upang mabawasan ang mga epekto ng noise.

Sa Qiskit, ito ay awtomatikong hinahawakan ng transpiler. Kapag pinili mo ang iyong backend, ginagawa ng transpiler ang lahat ng trabaho upang maging handa ang iyong circuit para sa execution, kaya hindi mo kailangang manu-manong ayusin ang mga gate o qubit assignment. Nag-aalok din ang transpiler ng iba't ibang antas ng optimization, na makakatulong sa pagbabawas ng mga error kung kinakailangan. Ang optimization ay ginagawa sa mga yugto na tinatawag na 'passes'. Kaya ang optimization na ito ay hahawakan ng pass_manager sa code sa ibaba. Para matuto nang higit pa tungkol sa mga error at error mitigation, tingnan ang Quantum Computing in Practice course ni Olivia Lanes.

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

## Load the Qiskit Runtime service
# QiskitRuntimeService.save_account(
#    channel="ibm_quantum_platform",
#    token="YOUR_TOKEN_HERE",
#    overwrite=True,
#    set_as_default=True,
# )
# service = QiskitRuntimeService(channel="ibm_quantum_platform")

# Or load saved credentials
service = QiskitRuntimeService()

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

ibm_fez

# Transpile the circuit and optimize for running on the quantum computer selected
# 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)

qc_isa.draw("mpl")

I-execute

Handa na tayong mag-execute! I-load natin ang Sampler, pagkatapos ay ipadala ang trabaho sa backend.

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

sampler = Sampler(mode=backend)

O, kung gumagamit ka ng simulator, maaari mong i-uncomment at patakbuhin ang cell na ito sa halip:

## Load the backend sampler
# from qiskit.primitives import BackendSamplerV2

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

# noise_model = NoiseModel.from_backend(backend)

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

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

job = sampler.run([qc_isa], shots=100)
# job = sampler_sim.run([qc_isa]) # uncomment if you want to run on a simulator
res = job.result()
counts = res[0].data.meas.get_counts()

Post-process

from qiskit.visualization import plot_histogram

print("counts = ", counts)
plot_histogram(counts)

counts =  {'10': 49, '01': 50, '11': 1}

Nakikita natin na ang karamihan ng counts ay nasa alinman sa 01 o 10, ibig sabihin kapag ang isang qubit ay sinukat na 0, ang isa pa ay 1, at vice-versa. Ito ay katugma sa Bell state $\vert \Psi^- \rangle$ na ating inihanda.

Eksperimento 2: Gamitin ang Estimator para sukatin ang enerhiya

Ngayong nakita na natin kung paano mag-sample ng quantum state, gamitin natin ang Estimator para kalkulahin ang enerhiya ng ating Bell state $\vert \Psi^- \rangle = \frac{1}{\sqrt{2}}(\vert 01 \rangle - \vert 10 \rangle)$.

I-map

Bilang paalala, ang enerhiya ng sistema ay tinutukoy ng pakikipag-ugnayan sa pagitan ng mga spin ($J$) at ang external magnetic field ($h_x$) tulad ng nakuha ng Hamiltonian:

$$H = J Z_1 Z_0 + h_x (X_1 + X_0)$$

Ang bawat termino sa Hamiltonian ay nagsasabi sa atin kung paano ang isang partikular na kombinasyon ng mga spin ay nag-aambag sa enerhiya. Sa Qiskit, maaari naming katawanin ang mga terminong ito bilang mga Pauli operator, na simpleng mga label para sa mga simpleng aksyon sa mga qubit:

• Ang $Z_1 Z_0$ ay kumikilos ng $Z$ sa parehong qubits.
• Ang $X_0$ ay kumikilos ng $X$ sa qubit 0.
• Ang $X_1$ ay kumikilos ng $X$ sa qubit 1.

Ang SparsePauliOp sa Qiskit ay isang paraan upang mag-imbak ng listahan ng mga Pauli operator na ito kasama ang kanilang numerical na coefficient. Ang mga Pauli operator na ito ay ang mga observable na gusto nating sukatin ng quantum computer — ang mga dami na nagsasabi sa atin tungkol sa sistema. Gamit ang Estimator, maaari nating kalkulahin ang average na halaga ng bawat observable sa ating state at pagsamahin ang mga ito ayon sa mga coefficient sa Hamiltonian para makuha ang kabuuang enerhiya.

# Import Qiskit primitives
from qiskit.quantum_info import SparsePauliOp

# Parameters
J = 1.0  # antiferromagnetic coupling (J<0)
hx = -0.5  # transverse field strength

# 1. Define the Hamiltonian H = J Z1 Z2 + hx (X1 + X2)
obs = SparsePauliOp.from_list([("ZZ", J), ("XI", hx), ("IX", hx)])

# Make state
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.x(1)
qc.z(0)

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

Pansinin na inalis natin ang qc.measure_all() na linya sa ating code. Ito ay dahil sa Estimator, hindi na natin kailangang tukuyin kung saan sukatin sa circuit. Sasabihin lang natin kung aling mga observable ang gusto nating matantya, at ang Qiskit ang bahala sa mga sukat sa likod ng eksena.

I-optimize

Ang hakbang ng optimization ay nagpapatuloy tulad ng dati, na may karagdagan ng pagtiyak na ang ating mga observable ay nasusulat din sa paraang mauunawaan ng quantum computer.

# Transpile the circuit and optimize for running on the quantum computer selected
# 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)
obs_isa = obs.apply_layout(layout=qc_isa.layout)

qc_isa.draw("mpl")

I-execute

Sa hakbang ng Execute, i-load natin ang Estimator, pagkatapos ay ipadala ang circuit kasama ang listahan ng mga observable na gusto nating tantiyahin sa quantum computer.

# Load the Runtime primitive and session
from qiskit_ibm_runtime import EstimatorV2 as Estimator

estimator = Estimator(mode=backend)

# Load the backend sampler

# noise_model = NoiseModel.from_backend(backend)

# Use Aer simulator in Estimator
# estimator_sim = BackendEstimatorV2(backend=backend_sim)

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

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

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

Post-process

Sa wakas, sa hakbang ng post-processing, simpleng ini-print natin ang enerhiyang kinakalkula sa likod ng eksena ng Estimator.

print(res[0].data.evs)

-0.9934112021453058

Ito ang enerhiya ng ating state!

Konklusyon

Sa araling ito, natutuhan natin kung paano maghanda ng simpleng two-qubit quantum state na kumakatawan sa dalawang nakikipag-ugnayang spin. Nakita natin kung paano gamitin ang Sampler upang obserbahan ang distribusyon ng mga measurement outcome at kung paano gamitin ang Estimator para kalkulahin ang enerhiya ng state ayon sa Hamiltonian. Sa daan, nakita natin kung paano ine-encode ng Hamiltonian ang mga pakikipag-ugnayan sa pagitan ng mga spin at ang mga epekto ng isang external field, at kung paano ang iba't ibang estado ay maaaring magkaroon ng iba't ibang enerhiya.

Pagpapalawak sa maraming spin

Sa ngayon, tinitingnan lang natin ang dalawang spin, na sapat na simple para suriin nang manu-mano. Sa mga tunay na pisikal na sistema, tulad ng sa isang magnet o iba pang kumplikadong materyales, kadalasan ay maraming nakikipag-ugnayang spin. Kapag nadagdagan ang bilang ng mga spin, nagiging mas kumplikado ang Hamiltonian at nagiging mas mahirap ang paghahanap ng pinakamababang-energy na state. Dito maaaring tumulong ang mga quantum computer: sa pamamagitan ng paghahanda ng iba't ibang estado at pagtatantya ng kanilang mga enerhiya, maaari nating mas mahusay na mag-explore ng mga low-energy configuration kaysa sa mga classical computer para sa malalaking sistema.

Ang isang natural na pagpapalawak ng eksperimentong ito ay ang dagdagan ang bilang ng mga qubit upang kumatawan sa mas maraming spin at ayusin ang paraan ng paghahanda ng mga spin upang subukang mahanap ang pinakamababang-energy na state. Ang diskarteng ito ay ang kakanyahan ng mga variational method, na maaari mong matutunan sa Variational Quantum Algorithms course.

Mayroon ding iba pang quantum approach sa pag-aaral ng ground-state energies na lampas pa sa mga variational technique. Ang mga pamamaraang ito ay hindi saklaw dito, ngunit ipinakilala sa Quantum Diagonalization Algorithms course kung interesado kang matuto nang higit pa.

Layunin sa pag-aaral

Bumalik sa simula ng Eksperimento 2 at subukan ulit ito gamit ang ibang superposition state. Makakahanap ka ba ng state na may mas mababang enerhiya kaysa sa ginamit natin?