Практичний вступ до критеріїв ДіВінченцо з Qiskit 2

Вступ

Фізик Девід ДіВінченцо сформулював п'ять ключових вимог до будь-якої фізичної реалізації квантового комп'ютера, а також два додаткові критерії для квантового зв'язку. У цьому ноутбуці ми відчуємо кожен критерій ДіВінченцо через практичні демонстрації у Qiskit. Замість глибокого занурення в теорію кожен розділ коротко пояснює один критерій, а потім пропонує задачі з кодом, що використовують Qiskit 2. Ти зможеш запускати Circuit на симуляторах і реальних пристроях IBM Quantum, щоб досліджувати кожен принцип на практиці.

П'ять критеріїв ДіВінченцо для квантових обчислень:

1. Масштабована фізична система з добре охарактеризованими Qubit.
2. Можливість ініціалізувати Qubit у простий еталонний стан (наприклад, |00…0〉).
3. Тривалий час декогеренції (час когеренції Qubit значно більший за час операції Gate).
4. Універсальний набір квантових Gate (здатний виконувати довільні унітарні операції).
5. Можливість вимірювання окремого Qubit (зчитувати стан кожного Qubit).

(ДіВінченцо також описав два критерії для квантового зв'язку: здатність взаємно перетворювати стаціонарні та «летючі» Qubit, і надійно передавати летючі Qubit між локаціями. Ми включаємо їх до рекомендованого завдання наприкінці цього ноутбука.)

Кожен із наступних розділів відповідає одному критерію. Ми використаємо Qiskit, щоб проілюструвати концепцію з кодом та інтерактивними експериментами, які ти можеш спробувати. Наприклад, ми побачимо, як збільшення кількості Qubit і глибини Circuit впливає на результати (Критерій 1), як скидати та підготовлювати стани Qubit (Критерій 2), як вимірювати Qubit на симуляторах та реальних пристроях (Критерій 4), як Qiskit складає універсальні Gate (Критерій 3), і як скінченна когеренція (T₁, T₂) впливає на обчислення (Критерій 5). Наприкінці ти матимеш глибшу інтуїцію щодо того, що означає кожен критерій ДіВінченцо на практиці і як Qiskit дозволяє з ними експериментувати.

# 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. Критерій 1 – Масштабовані, добре охарактеризовані Qubit

Критерій 1: «Масштабована фізична система з добре охарактеризованими Qubit.» Це означає, що нам потрібна квантова апаратна платформа, де ми можемо збільшувати кількість Qubit і при цьому надійно ними керувати. Властивості кожного Qubit (рівні енергії, частота помилок, зв'язність тощо) мають бути добре зрозумілі. По суті, ми хочемо будувати більші Circuit, не руйнуючи систему. На практиці зі збільшенням кількості Qubit або глибини Circuit накопичуються помилки та декогеренція, тому демонстрація масштабованості також означає розуміння того, як збільшення розміру впливає на продуктивність.

Мета демонстрації: Використати Qiskit, щоб показати вплив масштабування Circuit (за кількістю Qubit або глибиною Gate) на вихідну точність. Ми змоделюємо ідеальний та шумний сценарії, щоб побачити, як більша система або глибший Circuit піддаються декогеренції та помилкам.

Спочатку побудуємо невеликий заплутаний стан (стан GHZ) на 3 Qubit, потім більший — на 5 Qubit, як простий тест масштабування. Стан GHZ із n Qubit — це $\frac{1}{\sqrt{2}}(|0...0\rangle + |1...1\rangle)$. В ідеальній симуляції вимірювання n-кубітного GHZ дає лише два результати (всі 0 або всі 1) з рівною імовірністю. Ми порівняємо ідеальний результат з шумним результатом при збільшенні n або глибини 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}

Очікуваний результат (ідеальний випадок): Ідеально 3-кубітний GHZ дає приблизно 50% 000 і 50% 111 у відліках. 5-кубітний GHZ дає ~50% 00000 і 50% 11111. Інші бітові рядки не з'являються, оскільки стан в ідеалі є повністю когерентним і заплутаним. Ти маєш побачити два високих стовпчики на гістограмі для кожного Circuit, що відповідають результатам «всі нулі» та «всі одиниці».

Далі подивимося, що відбувається в шумному середовищі. Ми використаємо можливості моделювання шуму Qiskit Aer, щоб імітувати помилки реального пристрою. Наприклад, ми можемо взяти властивості Backend IBM і створити модель шуму, що включає помилки Gate, скінченний час Gate, релаксацію Qubit (T₁), дефазування (T₂) та помилки зчитування. Тут ми використаємо хибний Backend, що представляє пристрій IBM Quantum Brisbane, щоб згенерувати модель шуму та повторно запустити Circuit GHZ через неї.

Вправа 1а: Симуляція з шумом

Заповни наведений нижче код, щоб змоделювати Circuit GHZ на шумному симуляторі на основі Backend FakeBrisbane. Це покаже тобі, як продуктивність деградує при масштабуванні системи в реалістичному шумному середовищі.

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

Вправа 1б: Запуск на реальному квантовому комп'ютері IBM

Наведений нижче код запускає Circuit GHZ на реальному квантовому комп'ютері IBM. Це покаже тобі, як продуктивність деградує на реальному пристрої.

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

Очікуваний результат (шумний проти ідеального): З шумом, незалежно від того, змодельованим або на реальному пристрої, стан GHZ є менш досконалим. Ти побачиш додаткові результати, крім «всі 0» та «всі 1». Для 3 Qubit замість 100% у 000/111 деяка імовірність витікатиме в інші бітові рядки (наприклад, 001, 010 тощо) через помилки Gate або декогеренцію, що перевертає деякі Qubit. Для 5 Qubit ефект ще помітніший; більший Circuit (більше Qubit і Gate CNOT) накопичує більше помилок, тому піки «всі 0» та «всі 1» нижчі, і з'являється багато інших результатів. Ця тенденція ілюструє виклик масштабованості: зі збільшенням масштабу підтримувати високу точність стає важче без виправлення помилок.

Висновок: Масштабований квантовий комп'ютер має зберігати квантові кореляції при зростанні системи. Наші приклади показують, як збільшення кількості Qubit/глибини Gate призводить до зниження точності результатів за наявності шуму. Критерії, що залишилися, стосуватимуться підтримки Qubit у належному стані (з низькою похибкою, можливістю ініціалізації тощо) при масштабуванні.

2. Критерій 2 – Ініціалізація Qubit

Критерій 2: «Здатність ініціалізувати стан Qubit у простий еталонний стан, наприклад |000…〉.» Усі Qubit мають надійно починати роботу з відомого еталонного стану (зазвичай основного стану |0〉 для кожного Qubit). Ініціалізація є обов'язковою, щоб алгоритми починалися з чистого аркуша. На практиці на пристроях IBM Quantum кожен Qubit автоматично скидається до |0〉 на початку кожного виконання Circuit. Qiskit також надає інструкції для скидання Qubit або підготовки довільних станів під час обчислення.

Мета демонстрації: Показати, як ініціалізувати Qubit у Qiskit — як на початку, так і в середині Circuit. Ми продемонструємо використання інструкції reset та методів підготовки стану.

Вправа 2: Підготовка конкретного стану

У блоці коду нижче заповни QuantumCircuit, щоб підготувати стан $|10\rangle$. Це означає, що Qubit 0 має бути у стані $|0\rangle$, а Qubit 1 — у стані $|1\rangle$. Використай відповідний Gate та інструкцію для досягнення цього.

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)

Ти маєш побачити 10 (двійкове для qubit1=1, qubit0=0) з імовірністю 100% із симуляції, що означає успішну підготовку Qubit 1 у стані |1〉, а Qubit 0 — у стані |0〉.

Тепер для більш загальної підготовки стану Qiskit дозволяє ініціалізацію у довільні стани за допомогою методу initialize. Наприклад, підготуємо Qubit у стані $|+\rangle = (|0\rangle+|1\rangle)/\sqrt{2}$, який є станом суперпозиції, і пару Qubit у стані Белла $(|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}

Очікувані результати: Стан одного Qubit |+〉 при вимірюванні дасть 0 і 1 приблизно з імовірністю 50% кожен. Вимірювання стану Белла має дати приблизно 50% 00 і 50% 11. Якщо ти це бачиш, це підтверджує, що наша ініціалізація до цих станів була успішною.

Ініціалізація в середині Circuit: Інструкція reset у Qiskit може використовуватися в середині Circuit для реініціалізації Qubit до |0〉 під час виконання. Наприклад, у кодах виправлення помилок або ітераційних алгоритмах Qubit часто вимірюється, а потім скидається для повторного використання. Операція reset є детермінованою; вона скидає будь-який існуючий стан і охолоджує Qubit до основного стану.

Приклад пристрою: На апаратному забезпеченні, такому як ibmq_brisbane (127 Qubit) або будь-якому пристрої IBM, усі Qubit за замовчуванням починають у стані |0〉, коли запускається завдання. Якщо тобі потрібен інший початковий стан, на початку слід застосувати Gate (як ми зробили з X, щоб отримати |1〉). Безперервна реініціалізація (для квантового виправлення помилок) є активною темою досліджень, оскільки робити це швидко є складним завданням. На щастя, для базового використання можливість починати знову з |0…0〉 доступна, і ми продемонстрували, як досягти інших бажаних початкових станів.

3. Критерій 3 – Тривалий час когерентності (декогеренція vs час виконання Gate)

Критерій 3: «Тривалі часи декогеренції, що значно перевищують час виконання Gate-операції.» Це вимога до того, щоб Qubit-и зберігали свій квантовий стан достатньо довго для виконання необхідних операцій. Кожен Qubit має час T₁ (час релаксації енергії, як швидко |1〉 переходить у |0〉) та час T₂ (час дефазування, як швидко втрачається когерентність відносної фази). Щоб квантовий комп'ютер працював, ці часові масштаби мають значно перевищувати тривалість Gate-операцій.

Мета демонстрації: Дослідити когерентність Qubit-а в Qiskit, показавши, як декогеренція впливає на результати Circuit-а з ростом тривалості виконання. Ми використаємо фейковий Backend із відомими часами T1/T2, щоб симулювати цей ефект.

Щоб продемонструвати вплив кінцевої когерентності, ми симулюємо експеримент із загасанням T1. Ми підготуємо Qubit у стані |1〉, почекаємо певний час за допомогою інструкції delay, а потім виміряємо. Ми очікуємо, що ймовірність вимірювання |1〉 зменшуватиметься зі збільшенням затримки.

# 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

Вправа 3: Симуляція експерименту з загасанням T1

Тепер використай шумовий симулятор на основі FakeVigo (який має часи T1 ~50–100 мкс), щоб запустити ці Circuit-и. Симулятор автоматично застосує помилки T1/T2 під час інструкцій delay. Виконай транспіляцію Circuit-ів для цього Backend-у та запусти їх.

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. Критерій 4 – Універсальний набір квантових Gate-ів

Критерій 4: «"Універсальний" набір квантових Gate-ів.» Це означає, що наше апаратне забезпечення повинно дозволяти виконувати будь-які квантові обчислення шляхом компонування кінцевого набору базових Gate-ів. У класичних обчисленнях NAND є універсальним; у квантових існує багато варіантів універсальних наборів Gate-ів (наприклад, {H, T, CNOT} або нативні Gate-и конкретної машини). Пристрої IBM, наприклад, мають набір нативних операцій, як-от довільні однокубітні повороти та CNOT між певними Qubit-ами, що разом є універсальними. Завдання Qiskit часто полягає в тому, щоб компілювати Gate-и високого рівня в ці базисні Gate-и.

Мета демонстрації: Проілюструвати універсальність Gate-ів, показавши, як Qiskit розкладає Gate-и. Ми візьмемо ненативний Gate (наприклад, тригубітний Gate Тоффолі, CCX) і подивимось, як він розкладається на базисні Gate-и пристрою. Це демонструє, що наданий набір Gate-ів справді є універсальним — він може відтворити складнішу операцію.

По-перше, подивимось, які базисні Gate-и є для типового Backend-у IBM. Ми запитаємо конфігурацію пристрою (або його фейкової версії). Наприклад, базисні Gate-и ibmq_brisbane: Ти маєш помітити, що ймовірність P(qubit=1) зменшується зі збільшенням часу затримки, слідуючи кривій експоненціального загасання, характерній для релаксації T1. Це безпосередньо демонструє, як кінцевий час когерентності призводить до обчислювальних помилок, якщо Circuit виконується надто довго.

Вплив на алгоритми: Якщо ти спробуєш довший алгоритм (із багатьма послідовними Gate-ами), загальний час виконання може наблизитися до T2 або перевищити його, спричинивши втрату когерентності стану до завершення обчислення. Саме тому покращення часів когерентності та прискорення Gate-ів є двома з найважливіших цілей у дослідженнях квантового апаратного забезпечення.

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']

Це може вивести щось на зразок ['id', 'rz', 'sx', 'x', 'ecr']. Це примітивні операції, які апаратне забезпечення підтримує нативно (ідентичність/відсутність операції, поворот RZ, Gate sqrt(X), Gate X та controlled-X). Будь-який інший Gate має бути складений із них. Цей набір відомий як універсальний для квантових обчислень (по суті, однокубітні повороти плюс двокубітний Gate заплутування утворюють універсальний набір).

Тепер візьмемо Gate Тоффолі (CCX) як тестовий випадок. CCX перевертає цільовий Qubit лише тоді, коли обидва керуючі Qubit-и дорівнюють 1. Це ненативний Gate на апаратному забезпеченні IBM. Qiskit надає інструкцію ccx, але за лаштунками вона розкладається.

Вправа 4: Розкласти Gate Тоффолі

Заповни код нижче, щоб побудувати Circuit із Gate-ом Тоффолі (CCX), а потім використай Qiskit для розкладання його на нативні базисні Gate-и Backend-у 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))

У транспільованому виводі ти маєш побачити, що CCX замінено послідовністю більш базових Gate-ів, як-от rz, sx та ecr. Це доводить, що нативних Gate-ів достатньо для вираження Тоффолі.

Універсальність на практиці: Наведена вище вправа показує, що складний тригубітний Gate був побудований із простіших. Загалом будь-який багатокубітний унітарний оператор може бути складений із 1- та 2-кубітних Gate-ів. Transpiler є ключовим компонентом будь-якого стека квантового програмного забезпечення, оскільки він усуває розрив між абстрактними алгоритмами, які ми хочемо запустити, та фізичними операціями, які конкретний квантовий пристрій насправді може виконувати.

Приклад пристрою: Пристрій ibmq_brisbane використовує архітектуру Eagle із базисними Gate-ами, показаними вище. Це означає, що будь-який алгоритм, надісланий на ці машини, буде перетворено в послідовності таких операцій. Цей критерій по суті стосується керованості; у нас достатньо важелів управління, щоб виконати будь-яку необхідну операцію над нашими Qubit-ами.

5. Критерій 5 – Вимірювання Qubit-а

Критерій 5: «Можливість вимірювання, специфічна для кожного Qubit-а.» Стан кожного Qubit-а має бути вимірюваним (як правило, у обчислювальному базисі, |0〉 або |1〉). Іншими словами, після виконання квантового Circuit-у нам потрібно зчитати кожен Qubit як класичний біт 0/1. Цей критерій стосується наявності надійних детекторів для кожного Qubit-а та можливості обирати, які Qubit-и вимірювати.

Мета демонстрації: Показати, як виконувати вимірювання в Qiskit на симуляторах та реальних пристроях, і виділити відмінності (наприклад, шум вимірювання). Ми виміряємо деякі Qubit-и в різних станах і дослідимо результати. Ми також продемонструємо, як можуть з'являтися помилки зчитування, порівнюючи результати симулятора та апаратного забезпечення.

По-перше, простий приклад вимірювання:

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}

Ми очікуємо 1000 відліків 01 на симуляторі. Тепер подивимось на помилку вимірювання в дії, симулюючи її. Ми можемо додати помилку зчитування до нашого симулятора Aer. Qiskit Aer дозволяє нам визначити ReadoutError та прикріпити її до Qubit-ів у моделі шуму.

Вправа 5: Симуляція помилки зчитування

Заповни код для визначення простої моделі помилки зчитування, де кожен Qubit має 2% шанс бути виміряним неправильно (0 зчитується як 1, або 1 як 0). Потім запусти Circuit вимірювання з цією моделлю шуму.

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)

Цей симульований вивід показуватиме деякі помилкові відліки (як-от 11, 00, 10), подібні до тих, що може давати реальне апаратне забезпечення, демонструючи вплив недосконалого вимірювання.

Приклад пристрою: На реальному пристрої, як-от ibmq_brisbane, ти міг би запустити той самий Circuit і, найімовірніше, побачиш аналогічні ненульові відліки для неправильних результатів. Дані калібрування пристрою містять помилку зчитування для кожного Qubit-а. Можливість точково зчитувати конкретні Qubit-и є ключовою, а розуміння їхніх характеристик помилок — важливим для отримання осмислених результатів. Запуск на реальному пристрої було продемонстровано у Вправі 1b: Запуск на реальному квантовому комп'ютері IBM.

Критерії квантового зв'язку (Qubit-и, що «летять»)

ДіВінченцо також виклав два критерії, специфічні для квантового зв'язку, важливі при побудові мережевого квантового комп'ютера:

6. Можливість взаємного перетворення стаціонарних та «літаючих» Qubit-ів. (Наприклад, відображення Qubit-а в процесорі на фотон, що може переміщатися.)
7. Можливість надійної передачі «літаючих» Qubit-ів між місцями. (Наприклад, передача фотонного Qubit-а через волокно без втрати квантової інформації.)

Це виходить за межі стандартного використання Qiskit, оскільки Qiskit переважно працює зі стаціонарними Qubit-ами на чипі. Однак ми можемо проілюструвати концепцію цих критеріїв на простому прикладі: квантова телепортація. Телепортація показує перетворення стану стаціонарного Qubit-а на інформацію, що переноситься заплутаною парою («літаюча» частина) та класичним зв'язком, яка потім використовується для відтворення стану на іншому стаціонарному Qubit-і в іншому місці.

Рекомендована активність: пройди модуль Quantum Teleportation від Qiskit in Classrooms

Модуль Qiskit in Classrooms Quantum Teleportation від д-ра Кейті Маккормік проведе тебе через один із найзахопливіших протоколів у квантовій інформатиці: квантову телепортацію, де квантовий стан (Qubit) передається від Аліси до Боба за допомогою заплутування та лише двох класичних бітів. Ти вивчиш повну процедуру телепортації крок за кроком — як підготувати заплутану пару Белла, виконати вимірювання в базисі Белла на боці Аліси, передати класичні результати та застосувати правильний квантовий Gate до Qubit-а Боба, щоб ідеально відновити початковий стан. На цьому шляху ти дослідиш, чому телепортація інформації Qubit-а не порушує теорему про заборону клонування та не перевищує швидкість світла. Через практичні вправи з використанням апаратного забезпечення IBM Quantum або симуляторів ти здобудеш практичне розуміння вимірювання, заплутування та прямого управління в дії.

Опанувавши квантову телепортацію, ти зрозумієш, як кодувати, передавати та відновлювати квантову інформацію між окремими вузлами — що закладає основу для квантових мереж, систем ретрансляторів, схем захищеного зв'язку та масштабованих модульних квантових обчислень. Як це пов'язано з критеріями 6 і 7: У реальній квантовій мережі спільна заплутана пара створювалась би шляхом розповсюдження «літаючих» Qubit-ів (наприклад, фотонів) між місцями розташування Аліси та Боба (Критерій 7: надійна передача). Сам протокол телепортації слугує способом відображення стану стаціонарного Qubit-а Аліси на її половину заплутаної пари, фактично «відправляючи» його до Боба (Критерій 6: взаємне перетворення). Qiskit дозволяє нам ідеально симулювати логіку протоколу, надаючи концептуальну модель того, як ці критерії виконуються в комунікаційних архітектурах.

Висновок та підсумок

Ми розробили серію вправ, орієнтованих на код, для ілюстрації критеріїв ДіВінченцо за допомогою Qiskit. Через ці практичні приклади ти дослідив, як реальна платформа квантових обчислень відповідає кожній вимозі:

• Масштабованість: побудова Circuit-ів на більшій кількості Qubit-ів та розуміння масштабування шуму.
• Ініціалізація: використання скидань та підготовки стану для надійного запуску обчислень у відомих станах.
• Універсальні Gate-и: транспіляція складних операцій у базисні Gate-и машини, що доводить можливість виконання будь-яких обчислень.
• Вимірювання: зчитування Qubit-ів та робота з реалістичними помилками зчитування.
• Когерентність: спостереження впливу кінцевих T₁, T₂ на точність алгоритмів та необхідність того, щоб операції виконувались швидко відносно декогеренції.

Для повноти ми також торкнулись аспектів квантового зв'язку через модуль Qiskit in Classrooms Quantum Teleportation, пов'язуючи останні два критерії (Qubit-и, що «летять»).

Насамкінець варто зазначити, як ці критерії поєднуються в реальному квантовому комп'ютері IBM. Пристрій на зразок ibmq_brisbane має 127 надпровідних Qubit-ів (Критерій 1), кожен із яких починає в стані |0〉 (Критерій 2), із відкаліброваним набором Gate-ів та компіляторами для універсальності (Критерій 4), мікрохвильовими резонаторами зчитування для кожного Qubit-а (Критерій 5) та часами когерентності порядку сотень мікросекунд проти наносекундних операцій (Критерій 3). Для експериментів із квантовими мережами IBM та інші досліджують перетворення мікрохвиль в оптичний діапазон для «літаючих» Qubit-ів та заплутування віддалених Qubit-ів (Критерії 6 і 7); це активні напрямки досліджень.

Виконавши вправи в цьому зошиті, ти не лише побачив визначення критеріїв ДіВінченцо, але й доторкнувся до них через код; формуючи інтуїцію щодо того, що кожна вимога означає для реального квантового апаратного забезпечення та алгоритмів. Сміливо розширюй ці експерименти і щасливих квантових обчислень!