Фазовий перехід Нішіморі

Оцінка використання: 3 хвилини на процесорі Heron r2 (ПРИМІТКА: Це лише оцінка. Твій час виконання може відрізнятися.)

Результати навчання

Після проходження цього посібника очікуються такі результати:

• Розуміння фазового переходу Нішіморі та того, як він проявляється як поява далекодіючої заплутаності в моделі Ізінга з випадковими зв'язками.
• Реалізація протоколу генерації заплутаності вимірюванням (GEM) на квантовому обладнанні з використанням вимірювань всередині схеми та схем сталої глибини.
• Характеризація переходу шляхом вилучення двоточкової кореляції та нормованої дисперсії намагніченості з експериментальних даних.

Передумови

Рекомендуємо ознайомитися з такими темами перед проходженням цього посібника:

• Посібник Вимірювання кубітів, зокрема розділ про вимірювання всередині схеми, на якому базується протокол GEM.
• Точне та зашумлене моделювання з примітивами Qiskit Aer — саме так виконується розділ з малим масштабом.
• Далекодіяча заплутаність з динамічними схемами — супутній посібник, що використовує ту саму парадигму заплутаності на основі вимірювань.
• Ґратка heavy-hex — топологія обладнання IBM®, на якій побудована ґратка плакеток.

Передумови

Цей посібник демонструє, як реалізувати фазовий перехід Нішіморі на квантовому процесорі. Цей експеримент було спочатку описано в роботі Realizing the Nishimori transition across the error threshold for constant-depth quantum circuits.

Фазовий перехід Нішіморі стосується переходу між фазами з короткодіючим та далекодіючим порядком у моделі Ізінга з випадковими зв'язками. На квантовому комп'ютері фаза з далекодіючим порядком проявляється як стан, у якому кубіти заплутані по всьому пристрою. Цей сильно заплутаний стан підготовлюється за допомогою протоколу генерації заплутаності вимірюванням (GEM). Використовуючи вимірювання всередині схеми, протокол GEM здатний заплутувати кубіти по всьому пристрою за допомогою схем лише сталої глибини. У цьому посібнику використовується реалізація протоколу GEM із програмного пакету GEM Suite.

Вимоги

Перш ніж починати цей посібник, переконайся, що у тебе встановлено наступне:

• Qiskit SDK v1.0 або новіший, з підтримкою візуалізації
• Qiskit Runtime v0.22 або новіший (pip install qiskit-ibm-runtime)
• Qiskit Aer v0.14 або новіший (pip install qiskit-aer)
• GEM Suite (pip install gem-suite)

Налаштування

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

import matplotlib.pyplot as plt
import warnings

from collections import defaultdict

from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_aer import AerSimulator

from qiskit.transpiler import generate_preset_pass_manager

from gem_suite import PlaquetteLattice
from gem_suite.experiments import GemExperiment

Приклад із симулятором малого масштабу

У цьому розділі весь робочий процес розглядається на беззашумленому AerSimulator. Ґратка плакеток обмежена однією плакеткою (12 кубітів), щоб моделювання залишалось невеликим та швидким, але при цьому охоплювало кожну частину протоколу GEM: вимірювання всередині схеми, розгортку кута $R_{ZZ}$, декодування та аналіз нормованої дисперсії. Той самий робочий процес пізніше масштабується до кількох плакеток та повної ґратки на реальному обладнанні.

Крок 1: Відображення класичних вхідних даних на квантову задачу

Протокол GEM працює на квантовому процесорі зі зв'язністю кубітів, описаною ґраткою. Сучасні квантові процесори IBM Quantum® використовують ґратку heavy-hex. Кубіти процесора групуються в плакетки залежно від того, до якої елементарної комірки ґратки вони належать. Оскільки кубіт може входити до більш ніж однієї елементарної комірки, плакетки не є неперетинними. На ґратці heavy-hex плакетка містить 12 кубітів. Самі плакетки також утворюють ґратки, де дві плакетки з'єднані, якщо вони мають спільні кубіти. На ґратці heavy-hex сусідні плакетки мають три спільних кубіти.

У програмному пакеті GEM Suite фундаментальним класом для реалізації протоколу GEM є PlaquetteLattice, який представляє ґратку плакеток (відмінну від ґратки heavy-hex). PlaquetteLattice можна ініціалізувати з карти зв'язності кубітів. Наразі підтримуються лише карти зв'язності heavy-hex.

Наступна комірка коду ініціалізує ґратку плакеток із карти зв'язності квантового процесора (QPU). Ґратка плакеток не завжди охоплює весь апаратний засіб. Наприклад, ibm_torino має загалом 133 кубіти, але найбільша ґратка плакеток, що вміщується на пристрої, використовує лише 125 з них і складається з 18 плакеток; ibm_pittsburgh (156 кубітів) аналогічно вміщує 144 кубіти в 21 плакетку. Та сама закономірність справедлива для інших QPU на базі heavy-hex з різною кількістю кубітів.

# QiskitRuntimeService.save_account(channel="ibm_quantum", token="<YOUR_API_KEY>", overwrite=True,
# set_as_default=True)
service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=127
)
aer_backend = AerSimulator.from_backend(backend)
plaquette_lattice = PlaquetteLattice.from_coupling_map(backend.coupling_map)

print(f"Number of qubits in backend: {backend.num_qubits}")
print(
    f"Number of qubits in plaquette lattice: {len(list(plaquette_lattice.qubits()))}"
)
print(f"Number of plaquettes: {len(list(plaquette_lattice.plaquettes()))}")

Ти можеш візуалізувати ґратку плакеток, згенерувавши діаграму її графового представлення. На діаграмі плакетки представлені позначеними шестикутниками, а дві плакетки з'єднані ребром, якщо вони мають спільні кубіти.

plaquette_lattice.draw_plaquettes()

Ти можеш отримати інформацію про окремі плакетки, наприклад, які кубіти вони містять, за допомогою методу plaquettes.

# Get a list of the plaquettes
plaquettes = list(plaquette_lattice.plaquettes())
# Display information about plaquette 0
plaquettes[0]

PyPlaquette(index=0, qubits=[3, 4, 5, 6, 7, 16, 17, 23, 24, 25, 26, 27], neighbors=[4, 3, 1])

Ти також можеш створити діаграму базових кубітів, які формують ґратку плакеток.

plaquette_lattice.draw_qubits()

Окрім міток кубітів та ребер, що вказують на з'єднані кубіти, діаграма містить три додаткових елементи інформації, що стосуються протоколу GEM:

• Кожен кубіт є або зафарбованим (сірим), або незафарбованим. Зафарбовані кубіти — це кубіти «вузлів» (site), які представляють вузли моделі Ізінга, а незафарбовані кубіти — це кубіти «зв'язків» (bond), що використовуються для опосередкування взаємодій між кубітами вузлів.
• Кожен кубіт вузла позначений або (A), або (B), що вказує на одну з двох ролей, які кубіт вузла може виконувати в протоколі GEM (ролі пояснюються далі).
• Кожне ребро пофарбоване одним із шести кольорів, що розбиває ребра на шість груп. Це розбиття визначає, як можна розпаралелити двокубітні вентилі, а також різні схеми планування, які, ймовірно, матимуть різну кількість помилок на зашумленому квантовому процесорі. Оскільки ребра в одній групі не перетинаються, шар двокубітних вентилів може бути застосований на цих ребрах одночасно. Фактично, можна розбити шість кольорів на три групи по два кольори так, що об'єднання кожної групи з двох кольорів також буде неперетинним. Тому для активації кожного ребра потрібні лише три шари двокубітних вентилів. Існує 12 способів такого розбиття шести кольорів, і кожне таке розбиття дає інший 3-шаровий розклад вентилів.

Тепер, коли ти створив ґратку плакеток, наступним кроком є ініціалізація об'єкта GemExperiment, передавши як ґратку плакеток, так і бекенд, на якому ти маєш намір запустити експеримент. Клас GemExperiment керує фактичною реалізацією протоколу GEM, включаючи генерацію схем, надсилання завдань та аналіз даних. Наступна комірка коду ініціалізує клас експерименту, обмежуючи ґратку плакеток однією плакеткою (12 кубітів), що дозволяє симуляції залишатися невеликою та швидкою. Повна ґратка плакеток використовується пізніше при масштабуванні до реального обладнання.

# Filter the plaquette lattice down to a single plaquette (12 qubits)
# so the AerSimulator run stays fast. The full lattice is used later
# in the large-scale hardware example.
gem_exp = GemExperiment(plaquette_lattice.filter([9]), backend=aer_backend)

# visualize the plaquette lattice after filtering
plaquette_lattice.filter([9]).draw_qubits()

Схема протоколу GEM будується за такими кроками:

1. Підготовка стану «всі $|+\rangle$» шляхом застосування вентиля Адамара до кожного кубіта.
2. Застосування вентиля $R_{ZZ}$ між кожною парою з'єднаних кубітів. Це можна досягти за допомогою трьох шарів вентилів. Кожен вентиль $R_{ZZ}$ діє на кубіт вузла та кубіт зв'язку. Якщо кубіт вузла позначений (B), то кут фіксовано на $\frac{\pi}{2}$. Якщо кубіт вузла позначений (A), то кут може змінюватися, створюючи різні схеми. За замовчуванням діапазон кутів встановлюється як 21 рівномірно розподілена точка від $0$ до $\frac{\pi}{2}$ включно.
3. Вимірювання кожного кубіта зв'язку в базисі Паулі $X$. Оскільки кубіти вимірюються в базисі Паулі $Z$, це можна досягти, застосувавши вентиль Адамара перед вимірюванням кубіта.

Зверни увагу, що в статті, на яку посилається вступ до цього посібника, використовується інша конвенція для кута $R_{ZZ}$, яка відрізняється від конвенції, використаної в цьому посібнику, у 2 рази.

У кроці 3 вимірюються лише кубіти зв'язків. Щоб зрозуміти, в якому стані залишаються кубіти вузлів, корисно розглянути випадок, коли кут $R_{ZZ}$, застосований до кубітів вузлів (A) у кроці 2, дорівнює $\frac{\pi}{2}$. У цьому випадку кубіти вузлів залишаються у сильно заплутаному стані, подібному до стану GHZ,

$$\lvert \text{GHZ} \rangle = \lvert 00 \cdots 00 \rangle + \lvert 11 \cdots 11 \rangle.$$

Через випадковість результатів вимірювання фактичний стан кубітів вузлів може бути іншим станом з далекодіючим порядком, наприклад, $\lvert 00110 \rangle + \lvert 11001 \rangle$. Однак стан GHZ можна відновити, застосувавши операцію декодування на основі результатів вимірювання. Коли кут $R_{ZZ}$ зменшується від $\frac{\pi}{2}$, далекодіючий порядок все ще можна відновити аж до критичного кута, який за відсутності шуму становить приблизно $0.3 \pi$. Нижче цього кута результуючий стан більше не демонструє далекодіючу заплутаність. Цей перехід між наявністю та відсутністю далекодіючого порядку і є фазовим переходом Нішіморі.

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

В описі вище операція декодування може бути виконана застосуванням квантових вентилів до кубітів вузлів для відновлення квантового стану. Однак, якщо метою є негайне вимірювання стану (наприклад, для цілей характеризації), тоді кубіти вузлів можна виміряти разом з кубітами зв'язків, і операцію декодування можна застосувати на етапі класичної постобробки.

Окрім залежності від кута $R_{ZZ}$ у кроці 2, який за замовчуванням охоплює 21 значення, схема протоколу GEM також залежить від шаблону планування, що використовується для реалізації трьох шарів вентилів $R_{ZZ}$. Як обговорювалося раніше, існує 12 таких шаблонів планування. Тому загальна кількість схем в експерименті становить $21 \times 12 = 252$.

Схеми експерименту можна згенерувати за допомогою методу circuits класу GemExperiment.

circuits = gem_exp.circuits()
print(f"Total number of circuits: {len(circuits)}")

Total number of circuits: 252

Для цілей цього посібника достатньо розглянути лише один шаблон планування. Наступна комірка коду обмежує експеримент першим шаблоном планування. У результаті експеримент має лише 21 схему, по одній для кожного кута $R_{ZZ}$.

# Restrict experiment to the first scheduling pattern
gem_exp.set_experiment_options(schedule_idx=0)

# There are less circuits now
circuits = gem_exp.circuits()
print(f"Total number of circuits: {len(circuits)}")

# Print the RZZ angles swept over
print(f"RZZ angles:\n{gem_exp.parameters()}")

Total number of circuits: 21
RZZ angles:
[0.         0.07853982 0.15707963 0.23561945 0.31415927 0.39269908
 0.4712389  0.54977871 0.62831853 0.70685835 0.78539816 0.86393798
 0.9424778  1.02101761 1.09955743 1.17809725 1.25663706 1.33517688
 1.41371669 1.49225651 1.57079633]

Наступна комірка коду малює діаграму схеми з індексом 5. Для зменшення розміру діаграми вимірювальні вентилі в кінці схеми видалено.

# Get the circuit at index 5
circuit = circuits[5]
# Remove the final measurements to ease visualization
circuit.remove_final_measurements()
# Draw the circuit
circuit.draw("mpl", fold=-1, scale=0.5)

Крок 2: Оптимізація задачі для виконання на квантовому обладнанні

Трансляція квантових схем для виконання на обладнанні зазвичай включає кілька етапів. Як правило, етапи, що потребують найбільших обчислювальних витрат, — це вибір розташування кубітів, маршрутизація двокубітних вентилів відповідно до зв'язності кубітів обладнання та оптимізація схеми для мінімізації кількості вентилів та глибини. У протоколі GEM етапи розташування та маршрутизації є непотрібними, оскільки зв'язність обладнання вже враховано в дизайні протоколу. Схеми вже мають розташування кубітів, а двокубітні вентилі вже відображені на нативні з'єднання. Крім того, для збереження структури схеми при зміні кута $R_{ZZ}$ слід виконувати лише дуже базову оптимізацію схеми.

Клас GemExperiment прозоро транслює схеми під час виконання експерименту. Етапи розташування та маршрутизації за замовчуванням перевизначені для бездіяльності, а оптимізація схеми виконується на рівні, що оптимізує лише однокубітні вентилі. Однак ти можеш перевизначити або передати додаткові параметри за допомогою методу set_transpile_options. Для цілей візуалізації наступна комірка коду вручну транслює раніше відображену схему та малює трансльовану схему.

# Demonstrate setting transpile options
gem_exp.set_transpile_options(
    optimization_level=1  # This is the default optimization level
)
pass_manager = generate_preset_pass_manager(
    backend=aer_backend,
    initial_layout=list(gem_exp.physical_qubits),
    **dict(gem_exp.transpile_options),
)
transpiled = pass_manager.run(circuit)
transpiled.draw("mpl", idle_wires=False, fold=-1, scale=0.5)

Крок 3: Виконання за допомогою примітивів Qiskit

Для виконання схем протоколу GEM на обладнанні виклич метод run об'єкта GemExperiment. Ти можеш вказати кількість зразків (shots), які потрібно отримати з кожної схеми. Метод run повертає об'єкт ExperimentData, який слід зберегти у змінну. Зверни увагу, що метод run лише надсилає завдання без очікування їх завершення, тому це неблокуючий виклик.

exp_data = gem_exp.run(shots=10_000)

Щоб дочекатися результатів, виклич метод block_for_results об'єкта ExperimentData. Цей виклик призведе до зависання інтерпретатора до завершення завдань.

# The noiseless AerSimulator produces zero-variance UFloat objects in the
# analysis, which triggers a harmless warning from the `uncertainties`
# library. Suppress it so the output stays clean.
with warnings.catch_warnings():
    warnings.filterwarnings(
        "ignore", message="Using UFloat objects with std_dev==0"
    )
    exp_data.block_for_results()
exp_data

ExperimentData(GemExperiment, 90bf2a90-f729-4c4e-a6da-664aecb11039, job_ids=['04a7c405-47fd-46ca-aa4b-aaf7e339cfbe'], metadata=<5 items>, figure_names=['two_point_correlation.svg', 'normalized_variance.svg', 'plaquette_ops.svg', 'bond_ops.svg'])

Крок 4: Постобробка та повернення результату в бажаному класичному форматі

При куті $R_{ZZ}$, що дорівнює $\frac{\pi}{2}$, декодований стан був би станом GHZ за відсутності шуму. Далекодіючий порядок стану GHZ можна візуалізувати, побудувавши графік намагніченості виміряних бітових рядків. Намагніченість $M$ визначається як сума однокубітних операторів Паулі $Z$,

$$M = \sum_{j=1}^N Z_j,$$

де $N$ — кількість кубітів вузлів. Її значення для бітового рядка дорівнює різниці між кількістю нулів та кількістю одиниць. Вимірювання стану GHZ дає стан «всі нулі» або стан «всі одиниці» з рівною ймовірністю, тому намагніченість становитиме $+N$ половину часу та $-N$ іншу половину часу. За наявності помилок через шум також з'являтимуться інші значення, але якщо шум не надто великий, розподіл все ще матиме піки біля $+N$ та $-N$.

Для необроблених бітових рядків до декодування розподіл намагніченості був би еквівалентним розподілу рівномірно випадкових бітових рядків за відсутності шуму.

Наступна комірка коду будує графік намагніченості необроблених бітових рядків та декодованих бітових рядків при куті $R_{ZZ}$, що дорівнює $\frac{\pi}{2}$.

def magnetization_distribution(
    counts_dict: dict[str, int],
) -> dict[str, float]:
    """Compute magnetization distribution from counts dictionary."""
    # Construct dictionary from magnetization to count
    mag_dist = defaultdict(float)
    for bitstring, count in counts_dict.items():
        mag = bitstring.count("0") - bitstring.count("1")
        mag_dist[mag] += count
    # Normalize
    shots = sum(counts_dict.values())
    for mag in mag_dist:
        mag_dist[mag] /= shots
    return mag_dist

# Get counts dictionaries with and without decoding
data = exp_data.data()
# Get the last data point, which is at the angle for the GHZ state
raw_counts = data[-1]["counts"]
# Without decoding
site_indices = [
    i for i, q in enumerate(gem_exp.plaquettes.qubits()) if q.role == "Site"
]
site_raw_counts = defaultdict(int)
for key, val in raw_counts.items():
    site_str = "".join(key[-1 - i] for i in site_indices)
    site_raw_counts[site_str] += val
# With decoding
_, site_decoded_counts = gem_exp.plaquettes.decode_outcomes(
    raw_counts, return_counts=True
)

# Compute magnetization distribution
raw_magnetization = magnetization_distribution(site_raw_counts)
decoded_magnetization = magnetization_distribution(site_decoded_counts)

# Plot
plt.bar(*zip(*raw_magnetization.items()), label="raw")
plt.bar(*zip(*decoded_magnetization.items()), label="decoded", width=0.3)
plt.legend()
plt.xlabel("Magnetization")
plt.ylabel("Frequency")
plt.title("Magnetization distribution with and without decoding")

Text(0.5, 1.0, 'Magnetization distribution with and without decoding')

Для більш строгої характеризації далекодіючого порядку можна дослідити середню двоточкову кореляцію $f$, визначену як

$$f = \frac{1}{N^2} \left(\langle M^2 \rangle - \langle M \rangle ^2\right).$$

Більше значення вказує на більший ступінь заплутаності. Клас GemExperiment автоматично обчислює це значення для декодованих бітових рядків як частину обробки експериментальних даних. Він зберігає графік, доступний через метод figure класу експериментальних даних. У цьому випадку назва графіка — two_point_correlation.

exp_data.figure("two_point_correlation")

Для визначення критичної точки фазового переходу Нішіморі можна розглянути нормовану дисперсію $M^2 / N$, визначену як

$$g = \frac{1}{N^3} \left(\langle M^4 \rangle - \langle M^2 \rangle^2\right),$$

яка кількісно визначає рівень флуктуацій квадрата намагніченості. Це значення максимізується в критичній точці фазового переходу Нішіморі. За відсутності шуму критична точка знаходиться приблизно при $0.3 \pi$. За наявності шуму критична точка зсувається вище, але фазовий перехід все ще спостерігається, поки критична точка знаходиться нижче $0.5 \pi$.

exp_data.figure("normalized_variance")

Приклад із реальним обладнанням великого масштабу

Після перевірки протоколу на симуляторі можна масштабувати експеримент та запустити його на реальному квантовому бекенді, вибраному в розділі Налаштування. У цьому прикладі використовуються два більших розміри задачі:

• Шість плакеток (~49 кубітів): середній за розміром запуск, що вже демонструє зсув критичної точки вправо під впливом шуму обладнання.
• Повна ґратка плакеток: кожна плакетка, яку підтримує топологія heavy-hex пристрою (наприклад, 18 плакеток / 125 кубітів на ibm_torino або 21 плакетка / 144 кубіти на ibm_pittsburgh), заплутуючи кубіти по всьому пристрою за допомогою схем сталої глибини.

Єдина комірка коду нижче є самодостатньою: вона будує ґратку плакеток із карти зв'язності бекенду та запускає обидва експерименти, тому цей розділ можна виконати після комірок Налаштування без попереднього виконання розділу малого масштабу.

# -------------------------Step 1-------------------------
# Initialize the runtime service, pick a real quantum hardware backend,
# and build the plaquette lattice from its coupling map. This is repeated
# from the small-scale example so this cell can run standalone after the
# Setup section. The full plaquette lattice is the "large-scale" target;
# a six-plaquette subset (range(3, 9)) is also used to show an intermediate
# scaling step.
service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=127
)
plaquette_lattice = PlaquetteLattice.from_coupling_map(backend.coupling_map)

# Build a GemExperiment for the full plaquette lattice and one for the
# six-plaquette subset, each restricted to a single scheduling pattern so
# the experiment has one circuit per RZZ angle (21 circuits total).
gem_exp_full = GemExperiment(plaquette_lattice, backend=backend)
gem_exp_full.set_experiment_options(schedule_idx=0)
gem_exp_6 = GemExperiment(
    plaquette_lattice.filter(range(3, 9)), backend=backend
)
gem_exp_6.set_experiment_options(schedule_idx=0)

circuits = gem_exp_full.circuits()
print(f"Total number of circuits (full lattice): {len(circuits)}")

# -------------------------Step 2-------------------------
# GemExperiment transpiles internally for the target backend: the layout
# and routing stages are overridden because the plaquette lattice already
# matches the hardware connectivity, and optimization is restricted so the
# RZZ angle structure is preserved. The code below manually transpiles one
# circuit from the six-plaquette experiment with the same settings this
# experiment will use, and draws it for inspection. (The full-lattice
# transpiled circuit has too many qubits to visualize cleanly, so the
# six-plaquette circuit is used here as a representative example.)
gem_exp_6.set_transpile_options(optimization_level=1)
circuits_6 = gem_exp_6.circuits()
pass_manager = generate_preset_pass_manager(
    backend=backend,
    initial_layout=list(gem_exp_6.physical_qubits),
    **dict(gem_exp_6.transpile_options),
)
transpiled = pass_manager.run(circuits_6[5])
display(transpiled.draw("mpl", idle_wires=False, fold=-1, scale=0.5))

# -------------------------Step 3-------------------------
# Run both problem sizes on real hardware:
#   1. Six plaquettes (~49 qubits) — an intermediate scale-up.
#   2. The full plaquette lattice — every plaquette the device supports.
exp_data_6 = gem_exp_6.run(shots=10_000, job_tags=["TUT_NPT"])
exp_data_full = gem_exp_full.run(shots=10_000, job_tags=["TUT_NPT"])
exp_data_6.block_for_results()
exp_data_full.block_for_results()

# -------------------------Step 4-------------------------
# Plot the normalized variance at each scale. The peak marks the critical
# point of the Nishimori transition; as the system grows, hardware noise
# shifts the peak rightward.
display(exp_data_6.figure("normalized_variance"))
exp_data_full.figure("normalized_variance")

Total number of circuits (full lattice): 21

Зверни увагу, що залежно від рівня шуму використовуваного бекенду криві нормованої дисперсії для більших розмірів можуть не демонструвати чіткого піку в межах діапазону розгортки кутів. У наведених вище запусках пік було зсунуто аж до $0.5 \pi$, правого краю розгортки (аналіз повідомляє critical_angle = 0.5000 для обох запусків — шести плакеток та повної ґратки). Це означає, що шум обладнання зсунув критичну точку до межі (або трохи за межу) фізично значущого діапазону кутів протоколу, тому перехід знаходиться на краю того, що ця розгортка може розрізнити.

Висновок

У цьому посібнику ти реалізував фазовий перехід Нішіморі на квантовому процесорі за допомогою протоколу GEM. Метрики, які ти дослідив під час постобробки — зокрема, двоточкова кореляція та нормована дисперсія — слугують еталонними показниками здатності пристрою генерувати стани з далекодіючою заплутаністю. Ці еталонні показники розширюють застосування протоколу GEM за межі дослідження цікавої фізики. У рамках протоколу ти заплутав кубіти по всьому пристрою за допомогою схем лише сталої глибини. Цей подвиг можливий лише завдяки використанню протоколом вимірювань всередині схеми. У цьому експерименті заплутаний стан було одразу виміряно, але подумай про подальші дослідження, використовуючи цей стан у додатковій квантовій обробці.

Наступні кроки

Рекомендації

Якщо ця робота видалася тобі цікавою, можливо, тебе зацікавлять такі матеріали:

• Далекодіяча заплутаність з динамічними схемами
• Коди повторення
• Класичний зворотній зв'язок та керування потоком

Посилання

[1] E. H. Chen, G.-Y. Zhu, R. Verresen, A. Seif, E. Bäumer, D. Layden, N. Tantivasadakarn, G. Zhu, S. Sheldon, A. Vishwanath, S. Trebst, A. Kandala. Realizing the Nishimori transition across the error threshold for constant-depth quantum circuits. arXiv:2309.02863 (2023).

[2] GEM Suite software package.