Praktický úvod do DiVincenzových kritérií s Qiskit 2

Úvod

Fyzik David DiVincenzo popsal pět klíčových požadavků pro jakoukoli fyzikální implementaci kvantového počítače a také dvě další kritéria pro kvantovou komunikaci. V tomto notebooku si každé DiVincenzovo kritérium vyzkoušíš v praxi prostřednictvím ukázek v Qiskitu. Místo hlubokého ponoření do teorie každá sekce stručně vysvětlí jedno kritérium a poté nabídne cvičení s kódem v Qiskitu 2. Budeš mít možnost spouštět Circuit na simulátorech i na skutečných zařízeních IBM Quantum a zkoumat každý princip přímo v praxi.

DiVincenzových pět kritérií pro kvantové výpočty:

1. Škálovatelný fyzikální systém s dobře charakterizovanými Qubit.
2. Schopnost inicializovat Qubit do jednoduchého referenčního stavu (např. |00…0〉).
3. Dlouhé doby dekoherence (koherence Qubit musí být výrazně delší než doba provádění Gate).
4. Univerzální sada kvantových Gate (schopnost provádět libovolné unitární operace).
5. Schopnost měřit jednotlivé Qubit (přečíst stav každého Qubit).

(DiVincenzo také popsal dvě kritéria pro kvantovou komunikaci: schopnost vzájemně převádět stacionární a „létající" Qubit a věrně přenášet létající Qubit mezi místy. Tato kritéria zahrnujeme do doporučené aktivity na konci tohoto notebooku.)

Každá z následujících sekcí odpovídá jednomu kritériu. Pomocí Qiskitu ilustrujeme daný koncept s kódem a interaktivními experimenty, které si můžeš vyzkoušet. Například uvidíš, jak zvyšování počtu Qubit a hloubky Circuit ovlivňuje výsledky (Kritérium 1), jak resetovat a připravit stavy Qubit (Kritérium 2), jak měřit Qubit na simulátorech oproti reálným zařízením (Kritérium 4), jak Qiskit skládá univerzální Gate (Kritérium 3) a jak konečná koherence (T₁, T₂) ovlivňuje výpočty (Kritérium 5). Na konci budeš mít hlubší intuici pro to, co každé DiVincenzovo kritérium znamená v praxi a jak Qiskit umožňuje s nimi experimentovat.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy

# Install necessary packages
!pip install qiskit[visualization] qiskit-ibm-runtime qiskit-aer qiskit_ibm_runtime

1. Kritérium 1 – Škálovatelné, dobře charakterizované Qubit

Kritérium 1: „Škálovatelný fyzikální systém s dobře charakterizovanými Qubit." To znamená, že potřebujeme platformu kvantového hardwaru, kde můžeme zvyšovat počet Qubit a stále je spolehlivě ovládat. Vlastnosti každého Qubit (energetické hladiny, chybovost, propojení atd.) by měly být dobře pochopeny. V podstatě chceme stavět větší Circuit, aniž by systém přestal fungovat. V praxi, jak zvyšujeme počet Qubit nebo hloubku Circuit, hromadí se chyby a dekoherence, takže demonstrace škálovatelnosti také znamená pochopit, jak rostoucí velikost ovlivňuje výkon.

Cíl ukázky: Použij Qiskit k demonstraci vlivu škálování Circuit (v počtu Qubit nebo hloubce Gate) na věrnost výstupu. Budeme simulovat ideální vs. šumový scénář, abychom viděli, jak větší systém nebo hlubší Circuit podléhá dekoherenci a chybám.

Nejprve sestavme malý provázaný stav (stav GHZ) na 3 Qubit a poté větší na 5 Qubit jako jednoduchý test škálování. Stav GHZ pro n Qubit je $\frac{1}{\sqrt{2}}(|0...0\rangle + |1...1\rangle)$. V ideální simulaci měření n-qubitového GHZ dává pouze dva výsledky (samé 0 nebo samé 1) s rovnou pravděpodobností. Porovnáme ideální výstup s šumovým výstupem při zvyšování n nebo hloubky Circuit.

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import SamplerV2 as Sampler

# 3-qubit GHZ circuit
qc3 = QuantumCircuit(3, 3)
qc3.h(0)
qc3.cx(0, 1)
qc3.cx(1, 2)
qc3.measure([0, 1, 2], [0, 1, 2])

# 5-qubit GHZ circuit (scaling up the number of qubits)
qc5 = QuantumCircuit(5, 5)
qc5.h(0)
qc5.cx(0, range(1, 5))    # entangle qubit 0 with all others
qc5.measure(range(5), range(5))

# Transpile for a simulator backend
sim_backend = AerSimulator()
pm = generate_preset_pass_manager(backend=sim_backend, optimization_level=1)
isa_qc3 = pm.run(qc3)
isa_qc5 = pm.run(qc5)

# Run ideal simulations (no noise)
sampler = Sampler(mode=sim_backend)

job3 = sampler.run([isa_qc3], shots=1024)
result3 = job3.result()
counts3 = result3[0].data.c.get_counts()

job5 = sampler.run([isa_qc5], shots=1024)
result5 = job5.result()
counts5 = result5[0].data.c.get_counts()

print("3-qubit GHZ counts (ideal):", counts3)
plot_histogram(counts3, legend=['3-qubit ideal'], figsize=(6,4))

3-qubit GHZ counts (ideal): {'000': 531, '111': 493}

print("5-qubit GHZ counts (ideal):", counts5)
plot_histogram(counts5, legend=['5-qubit ideal'], figsize=(6,4))

5-qubit GHZ counts (ideal): {'11111': 535, '00000': 489}

Očekávaný výsledek (ideální případ): Ideální 3-qubitový GHZ dává přibližně 50 % 000 a 50 % 111 v počtech. 5-qubitový GHZ dává ~50 % 00000 a 50 % 11111. Žádné jiné bitové řetězce se neobjeví, protože stav je ideálně plně koherentní a provázaný. Na histogramu bys měl/a vidět dva vysoké sloupce pro každý Circuit odpovídající výsledkům samých nul a samých jedniček.

Dále se podívejme, co se stane v šumovém prostředí. Použijeme možnosti šumových modelů Qiskit Aer k napodobení chyb reálného zařízení. Například můžeme vzít vlastnosti backendu IBM a vytvořit šumový model zahrnující chyby Gate, konečné doby Gate, relaxaci Qubit (T₁), dephasing (T₂) a chyby čtení. Zde použijeme falešný Backend, který reprezentuje zařízení IBM Quantum Brisbane, k vygenerování šumového modelu, a znovu spustíme Circuit GHZ.

Cvičení 1a: Simulace se šumem

Dokonči níže uvedený kód pro simulaci Circuit GHZ na šumovém simulátoru založeném na Backendu FakeBrisbane. To ti ukáže, jak se výkon snižuje při škálování systému v realistickém šumovém prostředí.

from qiskit_ibm_runtime.fake_provider import FakeBrisbane

# We will reuse the ideal circuits qc3 and qc5 and their results from the previous cell.

# --- YOUR CODE HERE ---

# 1. Create a fake backend for IBM Quantum Brisbane
###brisbane_backend = ...

# 2. Create a noisy AerSimulator from the fake backend's properties
###noisy_sim = ...

# 3. Transpile the circuits for the noisy simulator (this adapts them to the device's specific gates and connectivity)
###pm = ...

###isa_qc3_noisy = ...

###isa_qc5_noisy = ...

# 4. Run the noisy simulations using the Sampler and get the counts
###sampler = ...

###job3 = ...

###result3_noisy = ...

###counts3_noisy = ...

###job5 = ...

###result5_noisy = ...

###counts5_noisy = ...

# --- END YOUR CODE ---

# This part is done for you to print and plot the results:
print("3-qubit GHZ counts (noisy):", counts3_noisy)
plot_histogram(counts3_noisy, legend=['3-qubit noisy'], figsize=(6,4))

print("5-qubit GHZ counts (noisy):", counts5_noisy)
plot_histogram(counts5_noisy, legend=['5-qubit noisy'], figsize=(6,4))

Cvičení 1b: Spuštění na skutečném kvantovém počítači IBM

Níže uvedený kód spustí Circuit GHZ na skutečném kvantovém počítači IBM. To ti ukáže, jak se výkon snižuje na reálném zařízení.

# your_api_key = "deleteThisAndPasteYourAPIKeyHere"
# your_crn = "deleteThisAndPasteYourCRNHere"

# QiskitRuntimeService.save_account(
#     channel="ibm_quantum_platform",
#     token=your_api_key,
#     instance=your_crn,
#     name="fallfest-2025",
# )

# Check that the account has been saved properly
# service = QiskitRuntimeService(name="fallfest-2025")
# print(service.saved_accounts())

# We will reuse the ideal circuits qc3 and qc5 and their results from the previous cell.

from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService(name="fallfest-2025")
real_backend = service.least_busy(operational=True, simulator=False)
print("Running on " + real_backend.name)

pm = generate_preset_pass_manager(backend=real_backend, optimization_level=1)
isa_qc3r = pm.run(qc3)
isa_qc5r = pm.run(qc5)

sampler = Sampler(mode=real_backend)

job3r = sampler.run([isa_qc3r], shots=1024)
result3r = job3r.result()
counts3r = result3r[0].data.c.get_counts()

job5r = sampler.run([isa_qc5r], shots=1024)
result5r = job5r.result()
counts5r = result5r[0].data.c.get_counts()

print("3-qubit GHZ counts (real):", counts3r)
plot_histogram(counts3r, legend=['3-qubit real'], figsize=(6,4))

print("5-qubit GHZ counts (real):", counts5r)
plot_histogram(counts5r, legend=['5-qubit real'], figsize=(6,4))

Očekávaný výsledek (šumový vs. ideální): Se šumem, ať simulovaným nebo na reálném zařízení, je stav GHZ méně dokonalý. Uvidíš další výsledky mimo samé 0 a samé 1. U 3 Qubit se místo 100 % v 000/111 část pravděpodobnosti přelije do jiných bitových řetězců (např. 001, 010 atd.) kvůli chybám Gate nebo dekoherenci překlápějící některé Qubit. U 5 Qubit je efekt ještě výraznější; větší Circuit (více Qubit a CNOT Gate) hromadí více chyb, takže vrcholy samých 0 a samých 1 jsou nižší a objevuje se mnoho dalších výsledků. Tento trend ilustruje výzvu škálovatelnosti: jak škálujeme nahoru, udržování vysoké věrnosti je bez opravy chyb stále obtížnější.

Poznatek: Škálovatelný kvantový počítač musí zachovávat kvantové korelace při růstu systému. Naše příklady ukazují, jak zvyšování počtu Qubit a hloubky Gate způsobuje při přítomnosti šumu pokles věrnosti výstupu. Zbývající kritéria se budou zabývat tím, jak udržet tyto Qubit v dobrém stavu (nízká chybovost, inicializovatelnost atd.) při škálování.

2. Kritérium 2 – Inicializace Qubit

Kritérium 2: „Schopnost inicializovat stav Qubit do jednoduchého referenčního stavu, jako je |000…〉." Všechny Qubit by měly spolehlivě začínat ve známém referenčním stavu (typicky základní stav |0〉 pro každý Qubit). Inicializace je nezbytná, aby algoritmy začínaly na čistém základě. V praxi jsou na zařízeních IBM Quantum všechny Qubit automaticky resetovány do |0〉 na začátku každého spuštění Circuit. Qiskit také poskytuje instrukce pro reset Qubit nebo přípravu vlastních stavů během výpočtu.

Cíl ukázky: Ukáž, jak inicializovat Qubit v Qiskitu, jak na začátku, tak uprostřed Circuit. Předvedeme použití instrukce reset a metod pro přípravu stavu.

Cvičení 2: Příprava konkrétního stavu

V níže uvedeném bloku kódu dokonči QuantumCircuit pro přípravu stavu $|10\rangle$. To znamená, že Qubit 0 by měl být ve stavu $|0\rangle$ a Qubit 1 ve stavu $|1\rangle$. K dosažení tohoto cíle použij odpovídající Gate a instrukci.

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

# Create a circuit to initialize qubits to |10> and verify by measurement
qc_init = QuantumCircuit(2, 2)

# --- YOUR CODE HERE ---

# 1. Set qubit 1 to the |1> state

# 2. Explicitly reset qubit 0 to the |0> state

# --- END YOUR CODE ---

qc_init.measure([0, 1], [0, 1])
qc_init.draw('mpl')

# Run the circuit and check the outcome
sim_backend = AerSimulator()
pm = generate_preset_pass_manager(backend=sim_backend, optimization_level=1)
isa_qc_init = pm.run(qc_init)

sampler = Sampler(mode=sim_backend)

job = sampler.run([isa_qc_init], shots=1024)
result = job.result()
counts = result[0].data.c.get_counts()

print("Outcome of |10> state measured in Z-basis:", counts)
plot_histogram(counts)

Měl/a bys vidět 10 (binárně pro qubit1=1, qubit0=0) se 100% pravděpodobností ze simulace, což znamená, že Qubit 1 byl úspěšně připraven v |1〉 a Qubit 0 v |0〉.

Nyní, pro obecnější přípravu stavu, Qiskit umožňuje inicializaci do libovolných stavů pomocí metody initialize. Například připravme Qubit ve stavu $|+\rangle = (|0\rangle+|1\rangle)/\sqrt{2}$, což je stav superpozice, a dvojici Qubit v Bellově stavu $(|00\rangle+|11\rangle)/\sqrt{2}$:

import numpy as np

# Initialize a single qubit in |+> state and measure in Z-basis
qc_plus = QuantumCircuit(1, 1)
state_plus = [1/np.sqrt(2), 1/np.sqrt(2)]   # amplitude for |0> and |1>
qc_plus.initialize(state_plus, 0)
qc_plus.measure(0, 0)

# Initialize two qubits in a Bell state manually
qc_bell = QuantumCircuit(2, 2)
bell_state = [1/np.sqrt(2), 0, 0, 1/np.sqrt(2)]  # amplitudes for |00>,|01>,|10>,|11>
qc_bell.initialize(bell_state, [0, 1])
qc_bell.measure([0, 1], [0, 1])

# Transpile and run the initialization circuits
isa_qc_plus = pm.run(qc_plus)
job_plus = sampler.run([isa_qc_plus], shots=1024)
result_plus = job_plus.result()
counts_plus = result_plus[0].data.c.get_counts()

print("Outcome of |+> state measured in Z-basis:", counts_plus)

isa_qc_bell = pm.run(qc_bell)
job_bell = sampler.run([isa_qc_bell], shots=1024)
result_bell = job_bell.result()
counts_bell = result_bell[0].data.c.get_counts()

print("Outcome of Bell state measured in Z-basis:", counts_bell)

Outcome of |+> state measured in Z-basis: {'1': 499, '0': 525}
Outcome of Bell state measured in Z-basis: {'00': 508, '11': 516}

Očekávané výsledky: Stav jednoho Qubit |+〉, při měření, dá 0 a 1 s přibližně 50% pravděpodobností každý. Měření Bellova stavu by mělo dát přibližně 50 % 00 a 50 % 11. Pokud toto vidíš, potvrzuje to, že naše inicializace do těchto stavů byla úspěšná.

Inicializace uprostřed Circuit: Qiskit's reset lze použít uprostřed Circuit pro znovuinicializaci Qubit do |0〉 za běhu. Například v kódech pro opravu chyb nebo iterativních algoritmech se Qubit často změří a poté resetuje pro opětovné použití. Operace reset je deterministická; zahodí jakýkoli existující stav a ochladí Qubit do základního stavu.

Příklad zařízení: Na hardwaru jako ibmq_brisbane (127 Qubit) nebo jakémkoli zařízení IBM začínají všechny Qubit v |0〉 ve výchozím nastavení při spuštění úlohy. Pokud bys potřeboval/a jiný počáteční stav, aplikoval/a bys Gate na začátku (jak jsme udělali s X pro získání |1〉). Průběžná znovuinicializace (pro kvantovou opravu chyb) je aktivním výzkumným tématem, protože její rychlé provádění je náročné. Naštěstí pro základní použití je schopnost začít znovu v |0…0〉 k dispozici a my jsme ukázali, jak dosáhnout i jiných požadovaných počátečních stavů.

3. Kritérium 3 – Dlouhá doba koherence (dekoherence vs. čas hradla)

Kritérium 3: „Dlouhé relevantní doby dekoherence, mnohem delší než doba provádění hradlových operací." To se týká potřeby, aby qubit udržoval svůj kvantový stav dostatečně dlouho, aby bylo možné provést potřebné operace. Každý qubit má čas T₁ (čas energetické relaxace, jak rychle |1〉 přechází do |0〉) a čas T₂ (čas defázování, jak rychle se ztrácí koherence relativní fáze). Aby kvantový počítač fungoval, musí tyto časové škály výrazně přesahovat trvání hradlových operací.

Cíl ukázky: Prozkoumej koherenci qubitů v Qiskitu tím, že ukážeš, jak dekoherence ovlivňuje výsledky Circuits při rostoucí délce výpočtu. Použijeme falešný Backend se známými časy T1/T2 k simulaci tohoto efektu.

Abychom demonstrovali dopad konečné koherence, nasimulujeme experiment rozpadu T1. Připravíme qubit ve stavu |1〉, počkáme nějaký čas pomocí instrukce delay a poté ho změříme. Očekáváme, že pravděpodobnost naměření |1〉 bude s rostoucím zpožděním klesat.

# This part is done for you. We are creating a list of circuits,
# each with a different delay time.

time_delays_ns = [0, 50000, 100000, 150000, 200000, 250000, 300000]  # delay durations in ns

decay_expts = []
for delay in time_delays_ns:
    qc = QuantumCircuit(1, 1)
    qc.x(0)  # initialize qubit to |1>
    if delay > 0:
        qc.delay(delay, 0, unit='ns')  # wait 'delay' nanoseconds
    qc.measure(0, 0)
    decay_expts.append(qc)

decay_expts[1].draw('mpl') # Visualize one of the circuits

Cvičení 3: Simulace experimentu rozpadu T1

Nyní použij hlučný simulátor založený na FakeVigo (který má časy T1 ~50–100 µs) ke spuštění těchto Circuits. Simulátor automaticky aplikuje chyby T1/T2 během instrukcí delay. Transpiluj Circuits pro tento Backend a spusť je.

from qiskit_ibm_runtime.fake_provider import FakeVigoV2 as FakeVigo
from qiskit_aer import AerSimulator

# --- YOUR CODE HERE ---

# 1. Create a noisy simulator from the FakeVigo backend
###sim_vigo = ...

# 2. Transpile the list of circuits for this simulator
###pm = ...

###isa_decay_expts = ...

# 3. Use the Sampler to run all the transpiled circuits in a single job
###sampler = ...

###job = ...

###result = ...

# --- END YOUR CODE ---

# This part is done for you to analyze and print the results.
for idx, (delay, qc) in enumerate(zip(time_delays_ns, isa_decay_expts)):
    counts = result[idx].data.c.get_counts()
    p1 = counts.get('1', 0) / 1000  # Assuming 1000 shots
    print(f"Delay {delay} ns: P(qubit=1) = {p1:.3f}")

4. Kritérium 4 – Univerzální sada kvantových Gate

Kritérium 4: „‚Univerzální' sada kvantových Gate." To znamená, že náš hardware musí umožňovat provádění libovolného kvantového výpočtu složením konečné sady základních Gate. V klasické informatice je NAND univerzální; v kvantovém světě existuje mnoho voleb univerzálních sad Gate (např. {H, T, CNOT} nebo nativní Gate konkrétního stroje). Zařízení IBM mají například sadu nativních operací jako libovolné jednoQubitové rotace a CNOTy mezi určitými Qubit, které jsou dohromady univerzální. Úlohou Qiskitu je často kompilovat vysokoúrovňové Gate do těchto základních Gate.

Cíl ukázky: Ilustrovat univerzalitu Gate tím, že ukážeme, jak Qiskit Gate rozkládá. Vezmeme nativní Gate (jako 3-Qubitový Toffoli Gate, CCX) a podíváme se, jak se rozloží na základní Gate zařízení. To demonstruje, že poskytnutá sada Gate je skutečně univerzální – dokáže vytvořit složitější operaci.

Nejprve se podíváme, jaké jsou základní Gate typického IBM Backendu. Dotážeme se na konfiguraci zařízení (nebo jeho falešné verze). Například základní Gate ibmq_brisbane: Měl/a bys pozorovat, jak pravděpodobnost P(qubit=1) s rostoucím zpožděním klesá, přičemž sleduje exponenciální křivku charakteristickou pro relaxaci T1. To přímo demonstruje, jak konečná doba koherence vede k výpočetním chybám, pokud Circuit běží příliš dlouho.

Dopad na algoritmy: Pokud zkusíš delší algoritmus (s mnoha sekvenčními Gate), může celková doba provádění přistoupit k T2 nebo ho překročit, čímž stav ztratí koherenci před koncem výpočtu. Proto jsou zlepšování dob koherence a zrychlování Gate dvěma z nejdůležitějších cílů výzkumu kvantového hardwaru.

from qiskit_ibm_runtime.fake_provider import FakeBrisbane
fake_brisbane = FakeBrisbane()
print("Basis gates for ibmq_brisbane:", fake_brisbane.configuration().basis_gates)

Basis gates for ibmq_brisbane: ['ecr', 'id', 'rz', 'sx', 'x']

Na výstupu by se mohlo zobrazit něco jako ['id', 'rz', 'sx', 'x', 'ecr']. To jsou primitivní operace, které hardware nativně podporuje (Identity/no-op, rotace RZ, Gate sqrt(X), Gate X a řízené X). Jakýkoli jiný Gate musí být složen z těchto. Tato sada je považována za univerzální pro kvantové výpočty (v podstatě jednoQubitové rotace plus splétací dvouQubitový Gate tvoří univerzální sadu).

Nyní vezměme Gate Toffoli (CCX) jako testovací případ. CCX překlopí cílový Qubit pouze tehdy, jsou-li oba řídicí Qubit v hodnotě 1. Na IBM hardwaru to není nativní Gate. Qiskit poskytuje instrukci ccx, ale interně ji rozloží.

Cvičení 4: Rozložení Gate Toffoli

Dokonči kód níže, aby vytvořil Circuit s Gate Toffoli (CCX) a poté použij Qiskit k jeho rozložení na nativní základní Gate Backendu FakeBrisbane.

from qiskit import QuantumCircuit
from qiskit_ibm_runtime.fake_provider import FakeBrisbane

# The fake_brisbane backend from the previous cell is reused here.

# --- YOUR CODE HERE ---

# 1. Create a circuit that can accommodate a Toffoli gate
###qc_toffoli = ...

# Apply a CCX gate with controls on qubits 0, 1 and target on qubit 2

# 2. Transpile the circuit to the fake Brisbane backend
###pm = ...

###isa_qc_toffoli = ...

# --- END YOUR CODE ---

print("Toffoli circuit before decomposition:")
print(qc_toffoli)

print("\nToffoli circuit after transpiling to Brisbane basis:")
# The .draw() method will now show the decomposed circuit
print(isa_qc_toffoli.draw(fold=120))

Na transpilovaném výstupu by ses měl/a podívat, jak je CCX nahrazen posloupností základnějších Gate jako rz, sx a ecr. To dokazuje, že nativní Gate jsou dostatečné k vyjádření Toffoli.

Univerzalita v praxi: Výše uvedené cvičení ukazuje, že složitý 3-Qubitový Gate byl sestaven z jednodušších. Obecně lze libovolnou vícequbitovou unitární transformaci složit z 1- a 2-Qubitových Gate. Transpiler je klíčovou součástí každého zásobníku kvantového softwaru, protože překlenuje propast mezi abstraktními algoritmy, které chceme spustit, a fyzickými operacemi, které konkrétní kvantové zařízení skutečně dokáže provést.

Příklad zařízení: Zařízení ibmq_brisbane používá architekturu Eagle se základními Gate uvedenými výše. To znamená, že každý algoritmus odeslaný na tato zařízení bude převeden na posloupnosti těchto operací. Toto kritérium je v podstatě o řiditelnosti; máme dostatek řídicích prvků k provedení jakékoli potřebné operace na našich Qubit.

5. Kritérium 5 – Měření Qubit

Kritérium 5: „Qubit-specifická schopnost měření." Stav každého Qubit musí být měřitelný (typicky v komputační bázi, |0〉 nebo |1〉). Jinými slovy, po spuštění kvantového Circuitu musíme přečíst každý Qubit jako klasický bit 0/1. Toto kritérium se týká spolehlivých detektorů pro každý Qubit a schopnosti vybrat, které Qubit měřit.

Cíl ukázky: Ukázat, jak provádět měření v Qiskitu na simulátorech a reálných zařízeních, a zdůraznit rozdíly (jako je šum při měření). Změříme některé Qubit v různých stavech a prozkoumáme výsledky. Také ukážeme, jak se mohou projevit chyby čtení, porovnáním výsledků ze simulátoru oproti hardwaru.

Nejprve jednoduchý příklad měření:

qc_measure = QuantumCircuit(2, 2)
qc_measure.x(0)              # qubit 0 -> |1>, qubit 1 stays |0>
qc_measure.measure([0, 1], [0, 1])
qc_measure.draw('mpl')

sim_backend = AerSimulator()
pm = generate_preset_pass_manager(backend=sim_backend, optimization_level=1)
isa_qc_measure = pm.run(qc_measure)
job = sampler.run([isa_qc_measure], shots=1000)
result = job.result()
counts = result[0].data.c.get_counts()

print("Simulator measurement counts:", counts)

Simulator measurement counts: {'01': 1000}

Na simulátoru očekáváme 1000 počtů 01. Nyní se podíváme na chybu měření v praxi tím, že ji nasimulujeme. K našemu simulátoru Aer můžeme přidat chybu čtení. Qiskit Aer nám umožňuje definovat ReadoutError a připojit ji ke Qubit v modelu šumu.

Cvičení 5: Simulace chyby čtení

Dokonči kód pro definování jednoduchého modelu chyby čtení, kde má každý Qubit 2% šanci být změřen nesprávně (0 je přečtena jako 1 nebo 1 jako 0). Poté spusť Circuit měření s tímto modelem šumu.

from qiskit_aer.noise import NoiseModel, ReadoutError

# --- YOUR CODE HERE ---

# 1. Define a 2% readout error for each single qubit.
# The format is a list of lists of probabilities: [[P(0|0), P(1|0)], [P(0|1), P(1|1)]]
# P(A|B) is the probability of measuring A given the state was |B>.
###ro_error = ...

# 2. Create a new noise model
###noise_model_ro = ...

# 3. Add the readout error to all qubits in the noise model
... # Hint: Use the add_all_qubit_readout_error method

# --- END YOUR CODE ---

sim_backend.set_options(noise_model=noise_model_ro)
pm = generate_preset_pass_manager(backend=sim_backend, optimization_level=1)
isa_qc_measure = pm.run(qc_measure)

# Run the measurement circuit with readout noise
sampler = Sampler(mode=sim_backend)

job = sampler.run([isa_qc_measure], shots=1024)
result = job.result()
counts = result[0].data.c.get_counts()

print("Simulation with 2% readout error:", counts)

Tento simulovaný výstup ukáže některé chybné počty (jako 11, 00, 10) podobné tomu, co by reálný hardware mohl produkovat, čímž demonstruje dopad nedokonalého měření.

Příklad zařízení: Na reálném zařízení, jako je ibmq_brisbane, bys mohl/a spustit stejný Circuit a pravděpodobně by ses dočkal/a podobných nenulových počtů pro nesprávné výsledky. Kalibrační data zařízení uvádějí chybu čtení pro každý Qubit. Schopnost cílit a číst konkrétní Qubit je klíčová a pochopení jejich chybových charakteristik je zásadní pro získání smysluplných výsledků. Spuštění na reálném zařízení bylo demonstrováno v Cvičení 1b: Spuštění na reálném kvantovém počítači IBM.

Kritéria kvantové komunikace (létající Qubit)

DiVincenzo také uvedl dvě kritéria specifická pro kvantovou komunikaci, důležitá při budování síťového kvantového počítače:

6. Schopnost vzájemné konverze stacionárních a létajících Qubit. (Např. namapování Qubit v procesoru na foton, který může cestovat.)
7. Schopnost věrně přenášet létající Qubit mezi místy. (Např. odeslání fotonového Qubit skrz vlákno bez ztráty kvantové informace.)

To přesahuje standardní použití Qiskitu, protože Qiskit primárně pracuje se stacionárními Qubit na čipu. Nicméně koncept těchto kritérií můžeme ilustrovat jednoduchým příkladem: kvantová teleportace. Teleportace ukazuje přeměnu stavu stacionárního Qubit na informaci přenášenou spleteným párem (část „létající") a klasickou komunikací, která je poté použita k rekonstrukci stavu na jiném stacionárním Qubit jinde.

Doporučená aktivita: Absolvuj modul Qiskit in Classrooms Kvantová teleportace

Modul Qiskit in Classrooms Quantum Teleportation od Dr. Katie McCormick tě provede jedním z nejpoutavějších protokolů v kvantové informaci: kvantovou teleportací, při které je kvantový stav (Qubit) odeslán od Alice k Bobovi pomocí spletení a pouhých dvou klasických bitů. Naučíš se celý postup teleportace krok za krokem – jak připravit spletený Bellův pár, provést měření v Bellově bázi na Alicině straně, přenést klasické výsledky a aplikovat správný kvantový Gate na Bobův Qubit, aby byl původní stav dokonale obnoven. Cestou prozkoumáš, proč teleportace informace Qubit neporušuje teorém o neklonování ani nepřekračuje rychlost světla. Prostřednictvím praktických cvičení na IBM Quantum hardwaru nebo simulátorech získáš praktické pochopení měření, spletení a řízení dopřednou vazbou v akci.

Zvládnutím kvantové teleportace pochopíš, jak kódovat, přenášet a obnovovat kvantovou informaci mezi různými uzly – čímž si položíš základ pro kvantové sítě, systémy opakovačů, schémata bezpečné komunikace a škálovatelné modulární kvantové výpočty. Jak to souvisí s kritérii 6 a 7: V reálné kvantové síti by byl sdílený spletený pár vytvořen distribucí „létajících" Qubit (jako fotonů) mezi místy Alice a Boba (Kritérium 7: věrný přenos). Samotný protokol teleportace pak slouží jako způsob, jak namapovat stav Alicina stacionárního Qubit na její polovinu spleteného páru, čímž ho efektivně „odešle" Bobovi (Kritérium 6: konverze). Qiskit nám umožňuje simulovat logiku protokolu dokonale, a tak poskytuje konceptuální model toho, jak jsou tato kritéria splněna v komunikačních architekturách.

Závěr a shrnutí

Navrhli jsme sérii na kód zaměřených cvičení k ilustraci DiVincenzových kritérií pomocí Qiskitu. Prostřednictvím těchto praktických příkladů jsi prozkoumal/a, jak reálná kvantová výpočetní platforma splňuje každý požadavek:

• Škálovatelnost: sestavování Circuits na více Qubit a pochopení škálování šumu.
• Inicializace: použití resetů a přípravy stavů ke spolehlivému zahájení výpočtů v known stavech.
• Univerzální Gate: transpilace složitých operací na základní Gate stroje, čímž dokazujeme, že můžeme provádět libovolný výpočet.
• Měření: čtení Qubit a práce s realistickými chybami čtení.
• Koherence: sledování dopadu konečných T₁, T₂ na věrnost algoritmů a potřeby, aby operace byly rychlé ve srovnání s dekoherencí.

Pro úplnost jsme se také dotkli aspektů kvantové komunikace prostřednictvím modulu Qiskit in Classrooms Quantum Teleportation, který propojuje poslední dvě kritéria (létající Qubit).

Na závěr stojí za zmínku, jak tato kritéria splývají v reálném kvantovém počítači jako IBM. Zařízení jako ibmq_brisbane má 127 supravodivých Qubit (Kritérium 1), každý začínající v |0〉 (Kritérium 2), s kalibrovanou sadou Gate a kompilátory pro univerzalitu (Kritérium 4), mikrovlnnými čtecími rezonátory pro každý Qubit (Kritérium 5) a dobami koherence v řádu stovek mikrosekund oproti nanosekundovým operacím (Kritérium 3). Pro experimenty s kvantovými sítěmi IBM a další zkoumají mikrovlnno-optickou transdukci pro létající Qubit a spletení vzdálených Qubit (Kritéria 6 a 7); to jsou aktivní výzkumné oblasti.

Dokončením cvičení v tomto notebooku jsi nejen/a viděl/a definice DiVincenzových kritérií, ale dotknul/a ses jich skrz kód; budování intuice o tom, co každý požadavek znamená pro reálný kvantový hardware a algoritmy. Neboj se tato experimentování rozšířit a přejeme ti příjemné kvantové programování!