Mensimulasikan alam

Tonton video dari Olivia Lanes tentang mensimulasikan alam dengan komputer kuantum, atau buka video di jendela terpisah di YouTube.

Pelajaran ini menggunakan konten dari tutorial ini:

Tutorial mitigasi error skala utilitas dengan amplifikasi error probabilistik

Pendahuluan

Salah satu aplikasi paling menarik dari komputer kuantum adalah kemampuannya untuk mensimulasikan fenomena alam. Dalam pelajaran ini, kita akan mengeksplorasi bagaimana komputer kuantum digunakan untuk memecahkan masalah dinamika kuantum—khususnya, bagaimana mereka membantu kita memahami evolusi waktu sistem kuantum.

Pertama, kita akan mengambil pandangan luas tentang langkah-langkah umum yang terlibat dalam menjalankan simulasi ini. Kemudian, kita akan memeriksa contoh konkret: eksperimen yang dipresentasikan IBM pada tahun 2023, yang memperlihatkan konsep utilitas kuantum. Eksperimen ini berfungsi sebagai studi kasus yang sangat baik untuk memahami langkah-langkah praktis dan implikasi dari mensimulasikan dinamika kuantum dengan perangkat keras kuantum nyata. Pada akhirnya, kamu akan memiliki gambaran yang lebih jelas tentang bagaimana para peneliti mendekati tantangan-tantangan ini dan mengapa simulasi kuantum memiliki potensi begitu besar untuk memajukan pemahaman kita tentang dunia alam.

Richard Feynman memberikan kuliah yang sangat berpengaruh di Caltech pada tahun 1959. Judulnya terkenal "There's Plenty of Room at the Bottom," sebagai kiasan playful terhadap kemungkinan-kemungkinan luas yang belum dijelajahi pada skala mikroskopik. Feynman berpendapat bahwa sebagian besar fisika pada tingkat atom dan subatom belum terungkap.

Signifikansi kuliah ini tumbuh pada 1980-an seiring kemajuan teknologi. Selama periode ini, Feynman meninjau kembali ide-ide ini dalam kuliah penting lainnya di Caltech, mempresentasikan makalah berjudul "Simulating Nature with Computers." Di sana, ia mengajukan pertanyaan berani: bisakah komputer digunakan untuk melakukan simulasi tepat yang mereplikasi perilaku alam pada tingkat kuantum? Feynman menyarankan bahwa, alih-alih mengandalkan aproksimasi kasar untuk memodelkan proses atom, kita bisa menggunakan komputer yang memanfaatkan hukum mekanika kuantum itu sendiri—bukan hanya untuk memodelkan alam, tetapi untuk mengemulasikannya.

Inilah jenis simulasi fisik yang akan kita periksa sepanjang pelajaran ini.

Ingat grafik garis waktu yang diperkenalkan dalam episode sebelumnya. Di satu ujung spektrum, kita melihat masalah yang mudah diselesaikan dan tidak memerlukan kecepatan tambahan yang mungkin dibawa oleh komputasi kuantum.

Di ujung yang berlawanan adalah masalah yang sangat menantang yang membutuhkan mesin kuantum yang sepenuhnya fault-tolerant — teknologi yang belum tersedia. Untungnya, banyak masalah simulasi diyakini berada di suatu tempat di tengah garis waktu ini, dalam kisaran di mana komputer kuantum saat ini sudah bisa diterapkan secara efektif. Ada banyak alasan untuk merasa bersemangat dan penasaran dengan prospek ini, karena mensimulasikan alam membentuk fondasi untuk berbagai aplikasi yang menjanjikan.

Informasi berikut mencakup alur kerja umum dalam simulasi alam dan kemudian contoh spesifik dari alur kerja untuk mereplikasi hasil dari studi yang terkenal.

Alur kerja umum

Sebelum siapa pun bisa menerapkan komputasi kuantum ke bidang-bidang menarik ini, penting untuk terlebih dahulu memahami langkah-langkah dasar dalam alur kerja simulasi tipikal:

1. Identifikasi Hamiltonian sistem
2. Pengkodean Hamiltonian
3. Persiapan state
4. Evolusi waktu dari state
5. Optimasi Circuit
6. Eksekusi Circuit
7. Pasca-pemrosesan

Prosesnya dimulai dengan mengidentifikasi sistem kuantum yang menarik. Ini membantu menentukan Hamiltonian yang mengatur evolusi waktunya, serta deskripsi yang bermakna tentang properti awalnya, atau state-nya. Selanjutnya, kamu perlu memilih metode yang tepat untuk mengimplementasikan evolusi waktu dari state ini. Perhatikan bahwa empat langkah pertama dalam alur kerja ini semuanya merupakan bagian dari langkah Pemetaan dalam kerangka Qiskit patterns.

Setelah menyiapkan Circuit evolusi waktu, tahap-tahap selanjutnya melibatkan pelaksanaan eksperimen sesungguhnya. Ini biasanya mencakup pengoptimalan Circuit kuantum yang mengimplementasikan algoritma evolusi waktu, menjalankan Circuit pada perangkat keras kuantum, dan pasca-memproses hasilnya. Ini sama dengan tiga langkah terakhir dalam kerangka Qiskit patterns.

Selanjutnya, kita akan membahas apa arti langkah-langkah ini sebelum kita melanjutkan ke pengkodean.

1. Identifikasi Hamiltonian sistem

Langkah penting pertama dalam melakukan eksperimen simulasi adalah mengidentifikasi Hamiltonian yang mendeskripsikan sistem. Dalam banyak kasus, Hamiltonian sudah mapan. Namun, kita sering membangunnya dengan menjumlahkan kontribusi energi dari bagian-bagian sistem yang lebih kecil. Ini biasanya dinyatakan sebagai jumlah suku-suku:

$$H=\sum_i^N {H_i}$$

di mana setiap suku $H_i$ bekerja pada salah satu dari $N$ subsistem lokal (seperti satu partikel atau kelompok kecil partikel) dari total Hamiltonian $H$. Dalam kasus partikel elementer yang tak dapat dibedakan, penting untuk menentukan apakah sistem melibatkan fermion atau boson, di mana fermion mematuhi Prinsip Pengecualian Pauli, yang berarti tidak ada dua fermion identik yang bisa menempati state kuantum yang sama seperti elektron. Tidak seperti fermion, beberapa boson bisa ada dalam state kuantum yang sama, dan perbedaan ini mempengaruhi statistik sistem dan bagaimana sistem itu harus dimodelkan.

Dalam praktiknya, orang sering tertarik pada sistem fisik di mana elemen-elemennya dianggap terpisah dengan baik atau berlabel, dan dengan demikian bisa dibedakan, seperti spin pada kisi.

Sistem ini terdiri dari spin dipol magnetik yang disusun pada kisi, yang diperlakukan sebagai partikel yang bisa dibedakan dengan menghitung alamatnya. Sistem ini dideskripsikan oleh Model Ising Medan Transversal, dan Hamiltoniannya dibangun dari jumlah dua bagian:

$$H = \sum_i^N {H_i} = J \sum_{<i,j>}Z_iZ_j + h\sum_{i=0}^N X_i$$

Di mana suku pertama mewakili energi interaksi antara spin yang bertetangga. Di sini $<i,j>$ menunjukkan bahwa kita menjumlahkan semua pasangan spin yang terhubung langsung pada kisi, $Z_i$ dan $Z_j$ adalah matriks Pauli-Z, yang mewakili state spin di situs $i$ dan $j$, dan $J$ adalah konstanta kopling, yang mendefinisikan kekuatan interaksi ini. Suku kedua mewakili pengaruh medan magnet eksternal yang diterapkan di seluruh sistem. Di sini $X_i$ adalah matriks Pauli-X yang bekerja pada spin individual di situs $i$, dan $h$ menunjukkan kekuatan medan eksternal ini.

2. Pengkodean Hamiltonian

Langkah berikutnya adalah menerjemahkan Hamiltonian ke dalam bentuk yang bisa diproses oleh komputer kuantum, yang kita sebut pengkodean. Proses pengkodean ini sangat bergantung pada jenis partikel dalam sistem: yang bisa dibedakan atau tidak bisa dibedakan, dan fermion atau boson, jika partikelnya tidak bisa dibedakan.

Jika kamu memiliki sistem dengan partikel yang bisa dibedakan, seperti spin $1/2$ yang tetap pada kisi, yang kita lihat sekilas di atas, Hamiltoniannya sering sudah ditulis dalam bahasa yang kompatibel dengan Qubit. Operator Pauli-Z, misalnya, secara alami mendeskripsikan spin atas atau bawah, dan tidak diperlukan pengkodean khusus.

Saat mensimulasikan partikel fermion atau boson yang tidak bisa dibedakan, perlu menerapkan transformasi pengkodean. Partikel-partikel ini digunakan untuk mendeskripsikan dalam kerangka matematika khusus yang disebut second quantization, yang melacak jumlah okupasi setiap state kuantum dengan memperkenalkan operator creation dan annihilation, di mana operator creation $\hat{a}_i^\dagger$ menambahkan satu partikel ke state $i$ sementara operator annihilation $\hat{a}_i$ menghapus satu partikel dari state $i$. Berdasarkan kerangka second quantization ini, fermion bisa ditransformasi dengan Bravyi-Kitaev dan Jordan-Wigner. Transformasi Jordan-Wigner mendefinisikan operator creation fermionic $\hat{f}_j^\dagger = \Bigl( \prod\limits_{k \lt j}{(-Z_k)} \Bigr)\Bigl( \frac{X_j + i Y_j}{2} \Bigr)$ yang mengisi state kuantum ke-$j$ dengan fermion dan operator annihilation fermionic $\hat{f}_j= \Bigl( \prod\limits_{k \lt j}{(-Z_k)} \Bigr)\Bigl( \frac{X_j - i Y_j}{2} \Bigr)$ yang mengosongkan fermion dari state ke-$j$. Kamu bisa menemukan detail lebih lanjut tentang transformasi Jordan-Wigner ini di Quantum Computing in Practice, episode 5 - Mapping kami. Demikian pula, boson juga memerlukan metode pengkodean mereka sendiri, seperti transformasi Holstein-Primakoff, untuk direpresentasikan oleh Qubit.

Pada akhirnya, baik jalurnya langsung maupun memerlukan terjemahan, tujuannya sama: mengekspresikan Hamiltonian sistem dalam bentuk operator spin Pauli yang bisa dipahami dan dieksekusi oleh komputer kuantum.

3. Persiapan state

Setelah mengkodekan Hamiltonian yang diinginkan ke dalam set Gate komputer kuantum, langkah penting berikutnya adalah memilih state kuantum awal yang tepat untuk memulai simulasi. Pilihan state awal tidak hanya mempengaruhi konvergensi algoritma variasional seperti Variational Quantum Eigensolver (VQE) tetapi juga mempengaruhi akurasi dan efisiensi evolusi waktu dan sampling. Pada dasarnya, state awal berfungsi sebagai titik awal untuk komputasi, meletakkan dasar untuk mengekstraksi observable yang berguna dari sistem kuantum yang dimodelkan. Idealnya, state ini harus mewakili konfigurasi yang bermakna secara fisik dari sistem yang diteliti.

Untuk banyak simulasi kimia kuantum, state Hartree-Fock bisa menjadi titik awal yang baik. Dalam bahasa second quantization, state Hartree-Fock ($|\phi\rangle_{HF}$) dibuat dengan menerapkan operator creation ($\hat{a}_i^\dagger$) untuk setiap orbital berenergi-terendah ke state vakum($|vac\rangle = |0_1 ... 0_k ... 0_N\rangle = |0\rangle ^{\otimes N}$), state tanpa elektron.

$$|\phi\rangle_{HF} = \prod\limits_{i=1}^k \hat{a}_i^\dagger |0\rangle ^{\otimes N} = \hat{a}_1^\dagger ... \hat{a}_k^\dagger |0_1 ... 0_k ... 0_N\rangle$$

Selain itu, ansatz yang mudah disiapkan dengan tumpang tindih signifikan dengan ground state sebenarnya bisa berfungsi sebagai state awal yang baik untuk masalah kimia, seperti menemukan energi ground state.

Secara lebih umum, kita bisa menulis state $n$-Qubit arbitrer sebagai superposisi state basis komputasi $∣c_i\rangle$ dengan koefisien $a_i$, yang memenuhi kondisi normalisasi. Mempersiapkan state seperti itu umumnya bisa didekati dengan menerapkan operator spesifik $\hat{O}$ ke state awal, yang biasanya adalah state basis standar all-zero berdasarkan konvensi.

$$|\psi\rangle = \sum_{i=0}^{2^n-1}{a_i |c_i\rangle}=\hat{O}|0\rangle^{\otimes n}\\ \text{with} \qquad \sum_{i=0}^{2^n-1}{|a_i^2|}=1$$

Namun, proses ini sering memerlukan jumlah Gate CNOT yang eksponensial, membuatnya umumnya membutuhkan banyak sumber daya. Kita sering berfokus pada mempersiapkan state awal yang implementasinya tidak terlalu rumit. Untuk alasan ini, kita sering berfokus pada mempersiapkan state awal yang kurang kompleks. Pilihan yang umum dan praktis adalah product state, di mana Qubit tidak terjalin, bisa disiapkan hanya menggunakan operasi single-Qubit, secara signifikan mengurangi kebutuhan sumber daya persiapan state dan kompleksitasnya. 4. Evolusi waktu dari state

Sekarang setelah state awal ditetapkan, kita akhirnya bisa memulai simulasi itu sendiri - memeriksa bagaimana state sistem $|\phi(t=0)\rangle$ berubah menjadi $|\phi(t)\rangle$ setelah beberapa waktu, $t$. Dalam mekanika kuantum, evolusi ini dideskripsikan oleh satu operasi matematika yang disebut operator evolusi waktu:

$$U(t) = e^{-iHt}$$

di mana kita telah menetapkan $\hbar=1$ berdasarkan konvensi. Menerapkan operator ini ke state awal kita menghasilkan state akhir: $|\phi(t)\rangle = e^{-iHt}|\phi(t=0)\rangle$

Namun, membangun Circuit kuantum yang langsung mengimplementasikan operator penuh $e^{-iHt}$ biasanya tidak mungkin ketika Hamiltonian kita adalah jumlah dari bagian-bagian yang berbeda. Oleh karena itu, kita memerlukan Trotterisasi.

Sederhananya, Trotterisasi adalah teknik untuk mengaproksimasi eksponensial dari matriks (di sini Hamiltonian, $H$), terutama ketika eksponen berisi operator yang tidak komut ($[H_A, H_B] \neq 0$). Sering kali Hamiltonian $H$ terdiri dari beberapa operator yang tidak komut. Dalam hal ini, kamu tidak bisa memisahkan eksponensialnya:

$$e^{-i(H_A + H_B)t} \neq e^{-iH_A t}e^{-iH_B t}$$

Pendekatan yang berguna adalah dengan secara bergantian menerapkan eksponensial evolusi waktu mereka selama durasi kecil, $t/n$, sebanyak $n$ kali. Dalam kasus dua kontribusi yang tidak komut ini, kita akan menulis

$$e^{−i H t}\approx \left(e^{−i H_A t/n}e^{−i H_B t/n}\right)^n$$

Error yang diperkenalkan oleh aproksimasi ini disebut error Trotter. Kita bisa mengurangi error ini dengan meningkatkan $n$, tetapi ini ada biayanya. Formula orde lebih tinggi yang lebih canggih (orde kedua dan varian lainnya) juga ada. Misalnya, formula orde kedua menawarkan akurasi yang lebih baik dengan menerapkan langkah-langkah dalam pola simetris.

$$\begin{aligned} \text{First order:} & \qquad e^{-iHt}\approx \left(\prod_j{e^{-iH_i t/n}}\right)^n\\ \text{Second order:} & \qquad e^{-iHt}\approx \left(\prod_{j=1}^N{e^{-iH_j t/2n}}\right)^n\left(\prod_{k=N}^1{e^{-iH_k t/2n}}\right)^n \end{aligned}$$

Di sini, $N$ adalah jumlah suku yang tidak komut, $H_j$, dalam Hamiltonian yang akan dipecah dengan cara ini, dan $n$ adalah jumlah langkah waktu kecil di mana evolusi ini dipecah. Perhatikan urutan terbalik dari operator dalam produk kedua dalam perlakuan orde kedua.

Lihat bagian Trotterisasi dalam kursus Quantum Diagonalization Algorithms untuk detail lebih lanjut. 5. Optimasi Circuit

Setelah menghasilkan Circuit yang di-Trotterisasi, langkah pemetaan selesai, dan kita bisa melanjutkan ke optimasi Circuit. Proses ini melibatkan beberapa tugas utama:

• Tetapkan tata letak Qubit yang memetakan Qubit abstrak dari Circuit ke Qubit fisik pada perangkat keras. Langkah ini diperlukan karena arsitektur perangkat keras sering memiliki batasan konektivitas tertentu, sementara desain Circuit kuantum biasanya mengasumsikan Qubit mana pun bisa berinteraksi dengan yang lainnya.
• Sisipkan Gate swap sesuai kebutuhan untuk mengaktifkan interaksi antara Qubit yang tidak terhubung langsung pada perangkat.
• Terjemahkan Gate Circuit ke instruksi Instruction Set Architecture (ISA) yang bisa langsung dieksekusi oleh perangkat keras.
• Lakukan optimasi Circuit untuk mengurangi kedalaman Circuit dan jumlah Gate. Optimasi ini juga bisa diterapkan lebih awal, pada Circuit virtual sebelum Qubit ditetapkan ke koneksi perangkat keras tertentu.

Penting untuk dicatat bahwa sebagian besar proses optimasi ini ditangani secara otomatis oleh alat-alat di Qiskit. Kita akan mengeksplorasi cara kerjanya nanti dalam pelajaran ini.

6. Eksekusi Circuit

Setelah menyelesaikan langkah optimasi, kita siap untuk mengeksekusi Circuit menggunakan primitif. Kita sedang mempertimbangkan eksperimen simulasi di mana tujuannya adalah memahami bagaimana properti tertentu dari sistem berubah seiring waktu. Untuk tujuan ini, primitif Estimator adalah pilihan yang paling tepat, karena memungkinkan kamu mengukur nilai ekspektasi dari observable yang sesuai dengan properti-properti ini.

Selanjutnya, kita menggunakan opsi termasuk teknik penekanan dan mitigasi error, untuk meningkatkan akurasi Estimator. Akhirnya, kita menjalankan eksperimen untuk mengumpulkan hasilnya.

7. Pasca-proses

Langkah terakhir adalah memproses data yang dikumpulkan secara pasca. Ini melibatkan mengekstraksi nilai ekspektasi yang diukur, atau, jika primitif Sampler digunakan, distribusi probabilitas yang disampling dalam basis komputasi. Ketika hanya nilai ekspektasi dari observable yang relevan yang dibutuhkan, ini bisa langsung diperoleh dari primitif Estimator, tersedia baik sebagai hasil mentah maupun dengan mitigasi error yang diterapkan. Sering kali, nilai ekspektasi yang diukur ini berfungsi sebagai titik awal untuk perhitungan tambahan yang melibatkan kuantitas lain yang diminati. Perhitungan tambahan seperti itu biasanya tidak memerlukan komputasi kuantum dan bisa dilakukan secara efisien pada komputer klasik.

Mereplikasi makalah "Utilitas"

catatan

Bagian ini adalah panduan tingkat tinggi dari tutorial Mitigasi error skala utilitas dengan amplifikasi error probabilistik, yang mereplikasi hasil dari makalah Evidence for the Utility of Quantum Computing Before Fault Tolerance. Kami sangat menyarankan kamu membuka tutorial yang direferensikan bersamaan dengan sesi ini.

Kita sekarang akan memeriksa contoh konkret dari makalah yang sangat berpengaruh yang diterbitkan IBM pada tahun 2023, berjudul Evidence for the Utility of Quantum Computing Before Fault Tolerance, yang sering disebut sebagai "makalah Utilitas".

Saat dirilis, karya ini dengan cepat menjadi studi penting dalam komunitas komputasi kuantum. Tesis sentralnya adalah bahwa komputer kuantum yang berisik, menggunakan 127 Qubit dan 2.880 Gate, bisa menghasilkan nilai ekspektasi yang akurat untuk Circuit kuantum yang berada di luar jangkauan metode simulasi klasik brute-force, yang mencoba simulasi tepat dari Circuit yang sama.

Studi ini sangat signifikan karena menunjukkan bahwa komputer kuantum bisa digunakan untuk memverifikasi atau membandingkan hasil dengan metode simulasi klasik aproksimasi, seperti algoritma tensor network—terutama dalam skenario di mana solusi tepat tidak diketahui sebelumnya.

Aspek luar biasa lain dari karya ini adalah bahwa karya ini telah banyak direproduksi: peneliti dan pengguna kini memiliki kemampuan untuk mereplikasi dan memverifikasi eksperimen menggunakan sistem kuantum yang dapat diakses melalui cloud IBM dan kerangka perangkat lunak Qiskit. Berikut, kita akan memandu kamu melalui langkah-langkah untuk melakukan replikasi ini sendiri dengan meninjau tutorial IBM langkah demi langkah.

Dalam pelajaran ini, kita mendiskusikan langkah-langkah spesifik yang diperlukan untuk menerjemahkan masalah ke dalam input yang bisa diproses oleh perangkat kuantum. Kita berfokus pada mensimulasikan dinamika total magnetisasi dalam sistem spin dipol magnetik yang disusun pada kisi, yang tunduk pada medan magnet eksternal. Sistem ini bisa dideskripsikan oleh model Ising dengan medan magnet transversal. Kita merepresentasikannya menggunakan Circuit kuantum terparameter, di mana parameter sesuai dengan nilai yang bisa diatur dari interaksi spin-spin ($ZZ$) dan kekuatan medan magnet transversal eksternal ($B_x$, diparametrasi menggunakan $X$).

Karena seri ini berjudul Quantum Computing in Practice, kita akan membahas detail tambahan tentang teknik eksperimental yang digunakan untuk meningkatkan kualitas hasil. Satu prosedur penting melibatkan identifikasi dan penghapusan Qubit "buruk"—Qubit dengan fidelitas Gate rendah atau waktu dekoherensi yang singkat—yang bisa secara signifikan mempengaruhi hasil eksperimen. Qubit yang bermasalah seperti itu mungkin muncul akibat kalibrasi yang buruk atau interaksi dengan two-level systems (TLS). Menghapus Qubit-Qubit ini mengubah topologi asli perangkat keras, secara efektif mengubah kisi di mana sistem disimulasikan.

Selain itu, kita akan mendiskusikan cara membangun Circuit kuantum terparameter yang mengimplementasikan evolusi waktu sistem menggunakan Trotterisasi. Bagian kunci dari proses ini adalah mengidentifikasi lapisan entangling dalam Circuit, yang memainkan peran penting dalam teknik mitigasi error utama.

Langkah Qiskit patterns 1: Peta

Tutorial menyelesaikan langkah pemetaan secara serupa dengan pendekatan umum yang dijelaskan di atas. Khusus untuk masalah ini, tutorial melakukan hal berikut:

• Membuat Circuit model Ising terparameter
• Membuat lapisan entangling dan menghapus Qubit buruk
• Menghasilkan versi Circuit yang di-Trotterisasi

Dalam tutorial, kita mulai dengan membuat serangkaian fungsi pembantu di awal notebook. Fungsi-fungsi ini dirancang untuk menyederhanakan proses saat kita melanjutkan. Ini bukan bagian yang diperlukan dari prosedur, tetapi ini adalah praktik umum yang baik saat mengerjakan eksperimen serupa: memecah masalah menjadi komponen yang bisa dikelola. Fungsi-fungsinya meliputi

• Hapus kopling Qubit
• Definisikan kopling Qubit
• Bangun kopling lapisan
• Bangun lapisan entangling
• Definisikan Circuit yang di-Trotterisasi

Di sini, mari jelajahi topik-topik yang terkait dengan fungsi-fungsi ini sedikit lebih lanjut. Kopling lapisan

Kopling lapisan mendefinisikan bagaimana Qubit berinteraksi dengan tetangganya selama simulasi. Perangkat kuantum kita menggunakan tata letak heavy-hexagonal, pola khas untuk menghubungkan Qubit. Dalam tata letak ini, koneksi antara Qubit—yang dikenal sebagai "edge"—bisa dibagi menjadi tiga set yang berbeda. Yang penting, tidak ada dua koneksi dalam set yang sama yang berbagi Qubit. Organisasi ini mengatasi batasan perangkat keras utama: pada komputer kuantum nyata, sebuah Qubit hanya bisa berpartisipasi dalam satu Gate dua-Qubit pada suatu waktu.

Dengan menyusun semua koneksi ke dalam tiga lapisan terpisah, Gate dua-Qubit bisa diterapkan di seluruh perangkat dalam tiga putaran berturut-turut. Ini memastikan bahwa tidak ada Qubit yang terlibat dalam lebih dari satu Gate per lapisan. Gate-Gate ini mengimplementasikan interaksi ZZ dalam model Ising, dan diulang pada setiap langkah waktu simulasi (setiap langkah Trotter).

Selain itu, teknik yang disebut twirling digunakan untuk memodifikasi karakteristik noise dalam perangkat. Twirling mengubah noise sehingga bahkan model noise yang sederhana menjadi representasi yang lebih akurat dari error fisik. Penyempurnaan ini memungkinkan karakterisasi noise yang lebih tepat, yang kemudian bisa dimanfaatkan untuk meningkatkan strategi mitigasi error. Menghapus Qubit "buruk"

Langkah berikutnya melibatkan penghapusan Qubit "buruk" dari daftar Qubit fisik yang tersedia untuk eksperimen. Sebuah Qubit bisa menjadi "buruk" karena berbagai alasan. Terkadang itu hanya masalah kalibrasi yang buruk, yang bisa diperbaiki dengan kalibrasi ulang. Dalam kasus lain, masalahnya lebih kompleks dan terkait dengan apa yang dikenal sebagai defek two-level system (TLS). Defek TLS ini menyebabkan fluktuasi dalam parameter Qubit dan relaksasi. Mengatasinya sering memerlukan pemanasan seluruh sistem dan kemudian pendinginan kembali—suatu proses yang bisa membutuhkan waktu dan tidak layak ketika mengakses perangkat keras kuantum dari jarak jauh melalui cloud.

Untuk saat ini, pendekatan paling sederhana adalah mengecualikan Qubit-Qubit bermasalah ini dari kumpulan Qubit fisik yang akan digunakan dalam eksperimen. IBM Quantum Platform® memudahkan identifikasi Qubit mana yang berkinerja buruk pada QPU. Kamu bisa membuka QPU dan memvisualisasikan karakteristiknya langsung di platform atau mengunduh data dari platform sebagai file CSV. Selanjutnya, buat daftar Qubit yang akan dikecualikan dan hapus dari total set Qubit fisik pada perangkat.

Menghapus Qubit yang tidak dapat diandalkan memastikan bahwa perilaku sistem lebih dapat diprediksi, yang meningkatkan akurasi eksperimen. Ini juga memungkinkan pemodelan noise yang lebih baik, yang penting untuk mengimplementasikan strategi mitigasi error yang efektif. Circuit yang di-Trotterisasi

Sekarang saatnya membangun Circuit yang di-Trotterisasi kita. Seperti yang telah dibahas sebelumnya, Trotterisasi memecah evolusi waktu menjadi langkah-langkah diskrit, jadi kita perlu memilih berapa banyak langkah yang akan digunakan. Untuk contoh ini, kita akan memilih enam langkah. Secara umum, pendekatannya melibatkan penyeimbangan error Trotter—error aproksimasi yang diperkenalkan oleh algoritma—dengan error yang disebabkan oleh dekoherensi. Meningkatkan jumlah langkah Trotter mengurangi error aproksimasi tetapi memerlukan Circuit kuantum yang lebih dalam, yang lebih rentan terhadap noise dekoherensi.

Circuit akan didefinisikan menggunakan beberapa parameter: parameter theta yang mewakili kekuatan medan magnet eksternal, kopling antara lapisan, jumlah langkah, jumlah Qubit, dan tentu saja, pilihan Backend perangkat. Karena magnetisasi sistem bergantung pada kekuatan medan magnet eksternal, sangat berharga untuk menjalankan simulasi pada nilai medan magnet yang berbeda. Variasi ini sesuai dengan sudut rotasi berbeda untuk Gate RX dalam Circuit.

from qiskit.circuit import Parameter

num_steps = 6           #Trotter steps
theta = Parameter("theta")
circuit = trotter_circuit(
        theta, layer_couplings, num_steps, qubits = good_qubits, backend = backend
)
num_params = 12

# 12 parameter values for Rx between [0,p/2].
#Reshape to outer product broadcast with observables

parameter_values = np.linespace(0,np.pi/2,num_params).reshape((num_params,1))
num_params = parameter_values.size

Langkah Qiskit patterns 2: Optimalkan

Sekarang setelah kita menghasilkan Circuit, langkah berikutnya adalah mengoptimalkannya. Bagian pertama dari proses ini melibatkan pendefinisian pass manager. Dalam konteks Qiskit SDK, transpilasi adalah proses transformasi Circuit input ke bentuk yang cocok untuk dieksekusi pada perangkat kuantum. Transformasi ini terjadi melalui serangkaian langkah yang dikenal sebagai transpiler pass. Pass manager adalah objek yang menyimpan daftar transpiler pass ini dan bisa menerapkannya ke Circuit. Untuk membuatnya, kamu menginisialisasi sebuah PassManager dengan daftar transpiler pass yang diinginkan. Pada akhirnya, pass manager menghasilkan Circuit ISA—Circuit yang dinyatakan dalam Instruction Set Architecture (ISA) dari Backend. Ini berarti Circuit direpresentasikan menggunakan Gate yang asli ke perangkat keras Backend, meskipun belum mencakup informasi waktu yang diperlukan untuk menjalankan Circuit pada perangkat.

Langkah Qiskit patterns 3: Eksekusi menggunakan primitif

Sekarang, saatnya menjalankan Circuit kita. Kita akan menggunakan Estimator sebagai alat utama untuk eksperimen ini karena tujuan kita adalah mengukur total magnetisasi sistem. Estimator dirancang khusus untuk memperkirakan nilai ekspektasi dari observable, menjadikannya pilihan ideal di sini. Pada tahap ini, penting juga untuk mengkonfigurasi pengaturan mitigasi error kita. Kita akan menerapkan Zero Noise Extrapolation (ZNE) untuk meningkatkan akurasi hasil kita. Dalam tutorial, kamu akan melihat bahwa kita menentukan dua atau lebih nilai faktor noise untuk mengevaluasi model yang diekstrapolasi, dan kita memilih "Probabilistic Error Amplification" (PEA) sebagai metode amplifikasi kita. PEA lebih disukai untuk eksperimen ini karena skalanya jauh lebih baik daripada opsi lain, yang sangat penting saat bekerja dengan sistem 100 Qubit atau lebih.

Ini semua yang diperlukan untuk menjalankan eksperimen.

Selingan mitigasi error

Sebelum kita melanjutkan ke pasca-pemrosesan, mari luangkan sejenak untuk mengklarifikasi apa yang dimaksud dengan Zero Noise Extrapolation (ZNE). Kita telah menyentuh konsep ini dalam episode-episode sebelumnya, tetapi ada baiknya untuk meninjaunya secara singkat. ZNE adalah teknik mitigasi error yang dirancang untuk mengurangi dampak noise yang tidak diketahui yang terjadi selama eksekusi Circuit kuantum, dengan syarat bahwa noise ini bisa diskalakan dengan cara yang terkontrol. Metode ini mengandalkan asumsi bahwa nilai ekspektasi berskala dengan noise menurut fungsi yang diketahui:

$$\langle A(\lambda)\rangle = \langle A(0)\rangle + \sum_{k=0}^m {a_k \lambda^k}+R,$$

di mana $λ$ mewakili kekuatan noise, yang bisa sengaja diperkuat.

Proses implementasi ZNE terdiri dari langkah-langkah berikut:

1. Perkuat noise Circuit untuk berbagai faktor noise $λ_1$, $λ_2$, … .
2. Eksekusi setiap Circuit yang diperkuat noisenya untuk mengukur nilai ekspektasi yang sesuai $\langle A(\lambda_1)\rangle$, $\langle A(\lambda_2)\rangle$, ….
3. Ekstrapolasi hasil-hasil ini kembali ke batas zero-noise \langle $A(\lambda_0)\rangle$.

Teknik ini memungkinkan kita untuk memperkirakan apa hasilnya jika tidak ada noise, meningkatkan akurasi komputasi kuantum.

Tantangan utama dalam mengimplementasikan ZNE secara efektif adalah mengembangkan model noise yang akurat untuk nilai ekspektasi dan memperkuat noise dengan cara yang terkontrol dan dipahami dengan baik. Teknik umum untuk amplifikasi error dalam ZNE mencakup penskalaan durasi pulse melalui kalibrasi, pengulangan Gate menggunakan siklus identitas, dan penambahan noise melalui sampling Pauli channel—metode yang dikenal sebagai Probabilistic Error Amplification (PEA).

Di antara metode-metode ini, PEA sering menjadi pilihan yang disukai karena beberapa alasan:

• Pulse stretching menimbulkan biaya komputasi yang tinggi.
• Gate folding, yang menggunakan penyisipan identitas, tidak memiliki jaminan teoretis yang kuat untuk mempertahankan bias noise.
• PEA berlaku untuk Circuit mana pun yang dieksekusi dengan faktor noise asli, meskipun memerlukan pembelajaran model noise terlebih dahulu.

PEA beroperasi dengan asumsi model noise berbasis lapisan yang mirip dengan yang digunakan dalam probabilistic error cancellation (PEC). Namun, tidak seperti PEC, PEA menghindari overhead sampling eksponensial yang biasanya tumbuh dengan noise Circuit. Efisiensi ini menjadikan PEA pendekatan yang praktis dan kuat untuk amplifikasi noise dalam ZNE, memfasilitasi mitigasi error kuantum yang lebih dapat diandalkan. Untuk mengkarakterisasi model noise, kita pertama-tama perlu mengidentifikasi lapisan-lapisan operasi dua-Qubit yang berbeda dalam Circuit. Untuk setiap lapisan ini, kita menerapkan prosedur Pauli twirling ke Gate dua-Qubit, yang membantu memastikan noise bisa dideskripsikan secara akurat dengan model noise damping. Selanjutnya, kita mengulangi pasangan lapisan identitas pada berbagai kedalaman, dan akhirnya, kita menyesuaikan nilai fidelitas untuk menentukan laju error untuk setiap kanal noise.

Meskipun bermanfaat untuk memahami metode ini secara konseptual, mengimplementasikannya secara manual di Qiskit jauh lebih sederhana, seperti yang ditunjukkan dalam tutorial yang menyertainya.

Langkah Qiskit patterns 4: Pasca-proses

Setelah eksperimen selesai, kamu bisa melihat hasilnya dengan melakukan pasca-pemrosesan. Garis abu-abu bertitik dalam data yang diplot mewakili hasil yang diperoleh menggunakan metode klasik aproksimasi, dengan error aproksimasi dikurangi ke ambang batas rendah. Titik data mentah untuk berbagai faktor noise, yang dipilih di awal, jelas tergeser dari garis bertitik ini. Sebaliknya, garis biru solid menampilkan data setelah menerapkan pemrosesan ZNE kita, yang secara mencolok membawa hasil jauh lebih dekat ke nilai tepat. Singkatnya, nilai yang diperoleh dalam kondisi noise normal (faktor noise nf=1.0) menunjukkan penyimpangan signifikan dari hasil tepat. Sementara itu, nilai yang dimitigasi selaras dengan tepat, menunjukkan efektivitas teknik mitigasi noise berbasis PEA.

Ringkasan

Untuk merangkum dengan cepat apa yang telah kita pelajari:

• Simulasi kuantum adalah salah satu bidang aplikasi yang paling menjanjikan dalam jangka pendek hingga menengah.
• Ini memiliki berbagai aplikasi, mulai dari farmasi hingga fisika energi tinggi, ilmu material, dan banyak lagi.
• Makalah Utilitas dari IBM, yang diterbitkan pada tahun 2023, menunjukkan jalan menuju kemampuan menggunakan komputer kuantum untuk penemuan ilmiah dan kita mengerjakan tutorial terkait yang menyertai makalah tersebut.
• Langkah-langkah untuk mengerjakan masalah simulasi dari awal sampai akhir relatif mudah, dan kami berharap kamu sekarang bisa menggunakan video dan tutorial ini sebagai panduan untuk lebih banyak masalah simulasi.

Survei pasca-kursus

Selamat telah menyelesaikan kursus ini! Silakan luangkan waktu sejenak untuk membantu kami meningkatkan kursus kami dengan mengisi survei singkat berikut. Umpan balikmu akan digunakan untuk meningkatkan penawaran konten dan pengalaman pengguna kami. Terima kasih!

Note: This survey is provided by IBM Quantum and relates to the original English content. To give feedback on doQumentation's website, translations, or code execution, please open a GitHub issue.