Peralihan fasa Nishimori

Anggaran penggunaan: 3 minit pada pemproses Heron r2 (NOTA: Ini adalah anggaran sahaja. Masa jalan anda mungkin berbeza.)

Hasil pembelajaran

Selepas melalui tutorial ini, pengguna dijangka memperoleh hasil berikut:

• Memahami peralihan fasa Nishimori dan bagaimana ia terzahir sebagai kemunculan belitan jarak jauh dalam model Ising ikatan rawak.
• Melaksanakan protokol generation of entanglement by measurement (GEM) pada perkakasan kuantum menggunakan pengukuran mid-Circuit dan Circuit berkedalaman malar.
• Mencirikan peralihan itu dengan mengekstrak korelasi dua-titik dan varians ternormal magnet daripada data eksperimen.

Prasyarat

Kami mengesyorkan kebiasaan dengan topik berikut sebelum melalui tutorial ini:

• Panduan Ukur qubit, khususnya bahagian tentang pengukuran mid-Circuit yang digunakan oleh protokol GEM.
• Simulasi tepat dan berbising dengan primitif Qiskit Aer, iaitu cara bahagian skala kecil dilaksanakan.
• Belitan jarak jauh dengan Circuit dinamik, tutorial rakan yang menggunakan paradigma belitan berasaskan pengukuran yang sama.
• Kekisi heavy-hex, topologi perkakasan IBM® tempat kekisi plaquette dibina.

Latar belakang

Tutorial ini menunjukkan cara merealisasikan peralihan fasa Nishimori pada pemproses kuantum. Eksperimen ini pada asalnya diterangkan dalam Realizing the Nishimori transition across the error threshold for constant-depth quantum circuits.

Peralihan fasa Nishimori merujuk kepada peralihan antara fasa teratur jarak pendek dan jarak jauh dalam model Ising ikatan rawak. Pada komputer kuantum, fasa teratur jarak jauh terzahir sebagai keadaan di mana Qubit-Qubit saling terbelit merentasi keseluruhan peranti. Keadaan yang sangat terbelit ini disediakan menggunakan protokol generation of entanglement by measurement (GEM). Dengan memanfaatkan pengukuran mid-Circuit, protokol GEM mampu membelit Qubit-Qubit merentasi keseluruhan peranti menggunakan Circuit yang hanya berkedalaman malar. Tutorial ini menggunakan pelaksanaan protokol GEM daripada pakej perisian GEM Suite.

Keperluan

Sebelum memulakan tutorial ini, pastikan anda telah memasang perkara berikut:

• Qiskit SDK v1.0 atau lebih baru, dengan sokongan visualisasi
• Qiskit Runtime v0.22 atau lebih baru (pip install qiskit-ibm-runtime)
• Qiskit Aer v0.14 atau lebih baru (pip install qiskit-aer)
• GEM Suite (pip install gem-suite)

Persediaan

# 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

Contoh simulator skala kecil

Dalam bahagian ini, keseluruhan aliran kerja ditelusuri pada AerSimulator tanpa bunyi. Kekisi plaquette dihadkan kepada satu plaquette sahaja (12 Qubit) supaya simulasi kekal kecil dan pantas, sambil tetap menguji setiap bahagian protokol GEM: pengukuran mid-Circuit, sapuan sudut $R_{ZZ}$, penyahkodan, dan analisis varians ternormal. Aliran kerja yang sama kemudiannya diskala naik kepada beberapa plaquette dan kekisi penuh pada perkakasan sebenar.

Langkah 1: Petakan input klasik kepada masalah kuantum

Protokol GEM beroperasi pada pemproses kuantum dengan kesambungan Qubit yang digambarkan oleh kekisi. Pemproses Quantum IBM® hari ini menggunakan kekisi heavy-hex. Qubit-Qubit pada pemproses dikumpulkan ke dalam plaquette berdasarkan sel unit kekisi yang mereka duduki. Oleh kerana satu Qubit mungkin terdapat dalam lebih daripada satu sel unit, plaquette-plaquette ini tidak disjoin. Pada kekisi heavy-hex, satu plaquette mengandungi 12 Qubit. Plaquette-plaquette itu sendiri juga membentuk kekisi, di mana dua plaquette disambungkan jika mereka berkongsi Qubit. Pada kekisi heavy-hex, plaquette-plaquette jiran berkongsi tiga Qubit.

Dalam pakej perisian GEM Suite, kelas asas untuk melaksanakan protokol GEM ialah PlaquetteLattice, yang mewakili kekisi plaquette (yang berbeza daripada kekisi heavy-hex). PlaquetteLattice boleh dimulakan daripada peta gandinggan Qubit. Buat masa ini, hanya peta gandinggan heavy-hex yang disokong.

Sel kod berikut memulakan kekisi plaquette daripada peta gandinggan unit pemproses kuantum (QPU). Kekisi plaquette tidak semestinya merangkumi keseluruhan perkakasan. Sebagai contoh, ibm_torino mempunyai 133 Qubit secara keseluruhan, tetapi kekisi plaquette terbesar yang muat pada peranti itu hanya menggunakan 125 daripadanya, merangkumi 18 plaquette; ibm_pittsburgh (156 Qubit) juga memuatkan 144 Qubit ke dalam 21 plaquette. Pola yang sama berlaku untuk QPU heavy-hex lain dengan bilangan Qubit yang berbeza.

# 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()))}")

Anda boleh menggambarkan kekisi plaquette dengan menjana rajah representasi grafnya. Dalam rajah tersebut, plaquette-plaquette diwakili oleh heksagon berlabel, dan dua plaquette disambungkan oleh tepi jika mereka berkongsi Qubit.

plaquette_lattice.draw_plaquettes()

Anda boleh mendapatkan maklumat tentang plaquette individu, seperti Qubit yang dikandunginya, menggunakan kaedah 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])

Anda juga boleh menghasilkan rajah Qubit-Qubit asas yang membentuk kekisi plaquette.

plaquette_lattice.draw_qubits()

Selain label Qubit dan tepi yang menunjukkan Qubit mana yang disambungkan, rajah ini mengandungi tiga maklumat tambahan yang berkaitan dengan protokol GEM:

• Setiap Qubit sama ada berlorek (kelabu) atau tidak berlorek. Qubit berlorek adalah Qubit "tapak" yang mewakili tapak model Ising, manakala Qubit tidak berlorek adalah Qubit "ikatan" yang digunakan untuk menjadi perantara interaksi antara Qubit tapak.
• Setiap Qubit tapak dilabel sama ada (A) atau (B), menunjukkan salah satu daripada dua peranan yang boleh dimainkan oleh Qubit tapak dalam protokol GEM (peranan-peranan itu dijelaskan kemudian).
• Setiap tepi diwarnakan menggunakan salah satu daripada enam warna, seterusnya membahagikan tepi kepada enam kumpulan. Pembahagian ini menentukan cara Gate dua-Qubit boleh diparalelkan, serta corak penjadualan berbeza yang mungkin menanggung jumlah ralat yang berbeza pada pemproses kuantum berbising. Oleh kerana tepi dalam satu kumpulan adalah disjoin, satu lapisan Gate dua-Qubit boleh digunakan pada tepi tersebut secara serentak. Malah, adalah mungkin untuk membahagikan enam warna ke dalam tiga kumpulan dua warna sedemikian rupa sehingga gabungan setiap kumpulan dua warna masih disjoin. Oleh itu, hanya tiga lapisan Gate dua-Qubit diperlukan untuk mengaktifkan setiap tepi. Terdapat 12 cara untuk membahagikan enam warna sedemikian, dan setiap pembahagian menghasilkan jadual Gate 3-lapisan yang berbeza.

Kini setelah anda mencipta kekisi plaquette, langkah seterusnya ialah memulakan objek GemExperiment, dengan menghantar kekisi plaquette dan Backend yang anda ingin jalankan eksperimen tersebut. Kelas GemExperiment menguruskan pelaksanaan sebenar protokol GEM, termasuk menjana Circuit, menghantar kerja, dan menganalisis data. Sel kod berikut memulakan kelas eksperimen sambil mengehadkan kekisi plaquette kepada satu plaquette sahaja (12 Qubit), mengekalkan simulasi kecil dan pantas. Kekisi plaquette penuh digunakan kemudiannya apabila diskala naik ke perkakasan sebenar.

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

Circuit protokol GEM dibina menggunakan langkah-langkah berikut:

1. Sediakan keadaan semua-$|+\rangle$ dengan menggunakan Gate Hadamard pada setiap Qubit.
2. Gunakan Gate $R_{ZZ}$ antara setiap pasangan Qubit yang disambungkan. Ini boleh dicapai menggunakan tiga lapisan Gate. Setiap Gate $R_{ZZ}$ bertindak pada Qubit tapak dan Qubit ikatan. Jika Qubit tapak dilabel (B), maka sudutnya ditetapkan pada $\frac{\pi}{2}$. Jika Qubit tapak dilabel (A), maka sudutnya dibenarkan untuk berubah, menghasilkan Circuit yang berbeza. Secara lalai, julat sudut ditetapkan kepada 21 titik berjarak sama antara $0$ dan $\frac{\pi}{2}$, inklusif.
3. Ukur setiap Qubit ikatan dalam asas Pauli $X$. Oleh kerana Qubit diukur dalam asas Pauli $Z$, ini boleh dicapai dengan menggunakan Gate Hadamard sebelum mengukur Qubit.

Perhatikan bahawa kertas kerja yang disebut dalam pengenalan tutorial ini menggunakan konvensyen berbeza untuk sudut $R_{ZZ}$, yang berbeza daripada konvensyen yang digunakan dalam tutorial ini sebanyak faktor 2.

Dalam langkah tiga, hanya Qubit ikatan yang diukur. Untuk memahami keadaan yang tinggal pada Qubit tapak, adalah berguna untuk mempertimbangkan kes di mana sudut $R_{ZZ}$ yang digunakan pada Qubit tapak (A) dalam langkah dua adalah sama dengan $\frac{\pi}{2}$. Dalam kes ini, Qubit tapak ditinggalkan dalam keadaan yang sangat terbelit yang serupa dengan keadaan GHZ,

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

Disebabkan kerawakan dalam hasil pengukuran, keadaan sebenar Qubit tapak mungkin adalah keadaan lain dengan perintah jarak jauh, contohnya, $\lvert 00110 \rangle + \lvert 11001 \rangle$. Walau bagaimanapun, keadaan GHZ boleh dipulihkan dengan menggunakan operasi penyahkodan berdasarkan hasil pengukuran. Apabila sudut $R_{ZZ}$ dikurangkan daripada $\frac{\pi}{2}$, perintah jarak jauh masih boleh dipulihkan sehingga sudut kritikal, yang dalam ketiadaan bunyi, adalah kira-kira $0.3 \pi$. Di bawah sudut ini, keadaan yang terhasil tidak lagi mempamerkan belitan jarak jauh. Peralihan antara kehadiran dan ketiadaan perintah jarak jauh ini adalah peralihan fasa Nishimori.

Dalam huraian di atas, Qubit tapak dibiarkan tidak diukur, dan operasi penyahkodan boleh dilakukan dengan menggunakan Gate kuantum. Dalam eksperimen seperti yang dilaksanakan dalam GEM suite, Qubit tapak sebenarnya diukur, dan operasi penyahkodan dilakukan dalam langkah pasca-pemprosesan klasik.

Dalam huraian di atas, operasi penyahkodan boleh dilakukan dengan menggunakan Gate kuantum pada Qubit tapak untuk memulihkan keadaan kuantum. Walau bagaimanapun, jika tujuannya adalah untuk mengukur keadaan dengan segera (contohnya, untuk tujuan pencirian), maka anda boleh mengukur Qubit tapak bersama dengan Qubit ikatan, dan melakukan operasi penyahkodan dalam langkah pasca-pemprosesan klasik.

Selain bergantung pada sudut $R_{ZZ}$ dalam langkah dua, yang secara lalai menyapu merentasi 21 nilai, Circuit protokol GEM juga bergantung pada corak penjadualan yang digunakan untuk melaksanakan tiga lapisan Gate $R_{ZZ}$. Seperti yang dibincangkan sebelum ini, terdapat 12 corak penjadualan sedemikian. Oleh itu, jumlah bilangan Circuit dalam eksperimen ialah $21 \times 12 = 252$.

Circuit-Circuit eksperimen boleh dijana menggunakan kaedah circuits kelas GemExperiment.

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

Total number of circuits: 252

Bagi tujuan tutorial ini, cukuplah untuk mempertimbangkan satu corak penjadualan sahaja. Sel kod berikut mengehadkan eksperimen kepada corak penjadualan pertama. Akibatnya, eksperimen hanya mempunyai 21 Circuit, satu untuk setiap sudut $R_{ZZ}$ yang disapu.

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

Sel kod berikut melukis rajah Circuit pada indeks 5. Untuk mengurangkan saiz rajah, Gate pengukuran di penghujung Circuit dibuang.

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

Langkah 2: Optimumkan masalah untuk pelaksanaan perkakasan kuantum

Transpilasi Circuit kuantum untuk pelaksanaan pada perkakasan biasanya melibatkan beberapa peringkat. Biasanya, peringkat yang menanggung overhead pengiraan paling banyak adalah memilih susun atur Qubit, melaraskan Gate dua-Qubit agar sesuai dengan kesambungan Qubit perkakasan, dan mengoptimumkan Circuit untuk meminimumkan bilangan Gate dan kedalamannya. Dalam protokol GEM, peringkat susun atur dan penghalaan tidak diperlukan kerana kesambungan perkakasan telah dimasukkan ke dalam reka bentuk protokol. Circuit sudah mempunyai susun atur Qubit, dan Gate dua-Qubit sudah dipetakan ke sambungan natif. Tambahan pula, bagi memelihara struktur Circuit apabila sudut $R_{ZZ}$ berubah, hanya pengoptimuman Circuit yang sangat asas sahaja yang perlu dilakukan.

Kelas GemExperiment secara telus melakukan transpilasi Circuit ketika menjalankan eksperimen. Peringkat susun atur dan penghalaan sudah ditolak lalainya untuk tidak melakukan apa-apa, dan pengoptimuman Circuit dilakukan pada tahap yang hanya mengoptimumkan Gate satu-Qubit. Walau bagaimanapun, anda boleh menolak atau menghantar pilihan tambahan menggunakan kaedah set_transpile_options. Untuk tujuan visualisasi, sel kod berikut mentranspilkan Circuit yang dipaparkan sebelum ini secara manual, dan melukis Circuit yang telah ditranspilkan.

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

Langkah 3: Laksanakan menggunakan primitif Qiskit

Untuk melaksanakan Circuit protokol GEM pada perkakasan, panggil kaedah run objek GemExperiment. Anda boleh menentukan bilangan shot yang ingin anda sampel daripada setiap Circuit. Kaedah run mengembalikan objek ExperimentData yang perlu anda simpan dalam pemboleh ubah. Perhatikan bahawa kaedah run hanya menghantar kerja tanpa menunggu ia selesai, jadi ini adalah panggilan bukan-penyekatan.

exp_data = gem_exp.run(shots=10_000)

Untuk menunggu keputusan, panggil kaedah block_for_results objek ExperimentData. Panggilan ini akan menyebabkan penterjemah berhenti sehingga kerja-kerja selesai.

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

Langkah 4: Pasca-proses dan kembalikan keputusan dalam format klasik yang dikehendaki

Pada sudut $R_{ZZ}$ sebesar $\frac{\pi}{2}$, keadaan yang dinyahkod akan menjadi keadaan GHZ tanpa kehadiran bunyi. Perintah jarak jauh keadaan GHZ boleh divisualisasikan dengan memplot magnet rentetan bit yang diukur. Magnet $M$ ditakrifkan sebagai jumlah operator Pauli $Z$ satu-Qubit,

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

di mana $N$ ialah bilangan Qubit tapak. Nilainya untuk satu rentetan bit adalah sama dengan perbezaan antara bilangan sifar dan bilangan satu. Mengukur keadaan GHZ menghasilkan keadaan semua sifar atau keadaan semua satu dengan kebarangkalian yang sama, jadi magnetnya adalah $+N$ separuh masa dan $-N$ separuh masa lagi. Dengan kehadiran ralat akibat bunyi, nilai-nilai lain juga akan muncul, tetapi jika bunyi tidak terlalu besar, taburannya masih akan memuncak berhampiran $+N$ dan $-N$.

Bagi rentetan bit mentah sebelum penyahkodan, taburan magnet akan setara dengan rentetan bit rawak seragam, tanpa kehadiran bunyi.

Sel kod berikut memplot magnet rentetan bit mentah dan rentetan bit yang dinyahkod pada sudut $R_{ZZ}$ sebesar $\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')

Untuk mencirikan perintah jarak jauh dengan lebih ketat, anda boleh memeriksa purata korelasi dua-titik $f$, yang ditakrifkan sebagai

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

Nilai yang lebih tinggi menunjukkan darjah belitan yang lebih besar. Kelas GemExperiment secara automatik mengira nilai ini untuk rentetan bit yang dinyahkod sebagai sebahagian daripada pemprosesan data eksperimen. Ia menyimpan gambar rajah yang boleh diakses melalui kaedah figure kelas data eksperimen. Dalam kes ini, nama gambar rajah ialah two_point_correlation.

exp_data.figure("two_point_correlation")

Untuk menentukan titik kritikal peralihan fasa Nishimori, anda boleh melihat varians ternormal $M^2 / N$, yang ditakrifkan sebagai

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

yang mengukur jumlah turun naik dalam magnet kuasadua. Nilai ini dimaksimumkan pada titik kritikal peralihan fasa Nishimori. Tanpa kehadiran bunyi, titik kritikal berlaku pada kira-kira $0.3 \pi$. Dengan kehadiran bunyi, titik kritikal beranjak ke nilai yang lebih tinggi, tetapi peralihan fasa masih dapat diperhatikan selagi titik kritikal berlaku di bawah $0.5 \pi$.

exp_data.figure("normalized_variance")

Contoh perkakasan skala besar

Setelah mengesahkan protokol pada simulator, anda kini boleh skala naik eksperimen dan menjalankannya pada Backend perkakasan kuantum sebenar yang dipilih dalam bahagian Persediaan. Contoh ini menggunakan dua saiz masalah yang lebih besar:

• Enam plaquette (~49 Qubit): jalankan bersaiz sederhana yang sudah menunjukkan anjakan ke kanan titik kritikal di bawah bunyi perkakasan.
• Kekisi plaquette penuh: setiap plaquette yang disokong oleh topologi heavy-hex peranti (contohnya, 18 plaquette / 125 Qubit pada ibm_torino atau 21 plaquette / 144 Qubit pada ibm_pittsburgh), membelit Qubit merentasi keseluruhan peranti dengan Circuit berkedalaman malar.

Sel kod tunggal di bawah adalah lengkap sendiri: ia membina kekisi plaquette daripada peta gandinggan Backend dan menjalankan kedua-dua eksperimen, jadi bahagian ini boleh dilaksanakan selepas sel-sel Persediaan tanpa perlu menjalankan bahagian skala kecil terlebih dahulu.

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

Perhatikan bahawa, bergantung pada tahap bunyi Backend yang digunakan, lengkung varians ternormal pada saiz yang lebih besar mungkin tidak menunjukkan puncak yang jelas dalam julat sudut yang disapu. Dalam jalankan di atas, puncak telah ditolak sepenuhnya ke $0.5 \pi$, hujung kanan sapuan (analisis melaporkan critical_angle = 0.5000 untuk kedua-dua jalankan enam-plaquette dan kekisi penuh). Ini bermakna bunyi perkakasan telah menganjak titik kritikal ke (atau sedikit melepasi) sempadan julat sudut protokol yang bermakna secara fizikal, jadi peralihan berada di pinggiran apa yang boleh diselesaikan oleh sapuan ini.

Kesimpulan

Dalam tutorial ini, anda merealisasikan peralihan fasa Nishimori pada pemproses kuantum menggunakan protokol GEM. Metrik yang anda periksa semasa pasca-pemprosesan — khususnya, korelasi dua-titik dan varians ternormal — berfungsi sebagai penanda aras kemampuan peranti untuk menjana keadaan terbelit jarak jauh. Penanda aras ini melanjutkan kegunaan protokol GEM melampaui penerokaan fizik yang menarik. Sebagai sebahagian daripada protokol, anda membelit Qubit-Qubit merentasi keseluruhan peranti menggunakan Circuit yang hanya berkedalaman malar. Pencapaian ini hanya mungkin disebabkan oleh penggunaan pengukuran mid-Circuit oleh protokol. Dalam eksperimen ini, keadaan terbelit terus diukur, tetapi pertimbangkan untuk meneroka lebih jauh dengan menggunakan keadaan ini dalam pemprosesan kuantum tambahan.

Langkah seterusnya

Cadangan

Jika anda mendapati kerja ini menarik, anda mungkin berminat dengan bahan berikut:

• Belitan jarak jauh dengan Circuit dinamik
• Kod ulangan
• Suapan balik klasik dan aliran kawalan

Rujukan

[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.