Membuat circuit SqDRIFT

Dengan sample-based quantum diagonalization (SQD), kamu harus memilih ansatz yang akan dijadikan sumber sampling bitstring. Varian SqDRIFT memakai ansambel circuit evolusi waktu yang dibangun langsung dari Hamiltonian target. Ini dicapai dengan men-subsampel operator evolusi waktu yang lebih kecil dari Hamiltonian berdasarkan koefisiennya, yang dikenal sebagai metode Trotterisasi qDRIFT.

Panduan memulai ini menunjukkan cara membuat ansambel circuit acak seperti itu.

1. Penyiapan Hamiltonian

Untuk keperluan panduan ini, muat Hamiltonian struktur elektronik N2 dari file FCIDUMP. Ada cara lain untuk membangun FermionOperator. Pastikan kamu membaca dokumentasinya, serta qiskit_fermions.operators.library.

PYTHON

>>> from qiskit_fermions.operators.library import FCIDump
>>> from qiskit_fermions.operators import FermionOperator
>>>
>>> fcidump = FCIDump.from_file("docs/guides/n2.fcidump")
>>> num_modes = 2 * fcidump.norb
>>> hamil = FermionOperator.from_fcidump(fcidump)

C

#include <qiskit_fermions.h>

QfFCIDump* fcidump = NULL;
qf_fcidump_from_file("docs/guides/n2.fcidump", &fcidump);
QfFermionOperator* hamil = qf_ferm_op_from_fcidump(fcidump);
uint32_t num_modes = 2 * qf_fcidump_norb(fcidump);

2. Kelompokkan suku Hamiltonian

Manfaatkan banyak simetri yang ada dalam Hamiltonian struktur elektronik dengan mengelompokkan suku-suku terkait yang memiliki koefisien identik. Tindakan ini mengubah distribusi koefisien operator yang disampel oleh protokol qDRIFT, tetapi tidak memengaruhi jaminan konvergensinya. Yang terpenting, mengelompokkan suku yang terkait lewat simetri menghasilkan pembatalan suku Pauli yang menguntungkan, sehingga kedalaman circuit secara keseluruhan lebih pendek saat mengevolusi suatu state terhadap aksinya.

Modul qiskit_fermions.operators.terms.grouping menyediakan fungsi praktis untuk mengelompokkan suku-suku sebuah operator. Hal ini dijelaskan lebih rinci di panduan ini.

Perhatian

Implementasi group_terms_by_electronic_structure() mengasumsikan suku-suku Hamiltonian sudah berurutan normal (normal-ordered)!

PYTHON

>>> from qiskit_fermions.operators.terms.grouping import group_terms_by_electronic_structure
>>> from qiskit_fermions.operators.terms.ordering import canonical_order
>>>
>>> canon = canonical_order(hamil.normal_ordered().simplify(atol=1e-16))
>>> exit_code = group_terms_by_electronic_structure(canon, num_modes, two_body_physicist_order=False)
>>> assert exit_code is None
>>> print(canon.groups)  # the groups attribute now contains some list of group indices
[0, ...]

C

QfFermionOperator* normal = qf_ferm_op_normal_ordered(hamil, NULL);
QfFermionOperator* simplified = qf_ferm_op_simplify(normal, 1e-16);
QfFermionOperator* canon = qf_ferm_op_canonical_order(simplified);
QfExitCode exit = qf_ferm_op_group_terms_by_electronic_structure(canon, num_modes, false);
assert(exit == QfExitCode_Success);

qf_ferm_op_free(normal);
qf_ferm_op_free(simplified);

Petunjuk

Hamiltonian struktur elektronik lengkap memuat suku-suku tertentu yang jika dimasukkan ke circuit evolusi waktu tidak berdampak pada bitstring yang teramati, sehingga hanya menambah overhead sampling. Karena itu, disarankan agar suku-suku tersebut disaring dari Hamiltonian pada tahap ini, sebelum membangun gate Evolution di langkah berikutnya.

Suku-suku yang sesuai deskripsi ini adalah yang diagonal dalam basis bilangan okupansi, yaitu hasil kali operator bilangan ($a^\dagger_i a_i$). Ini mencakup offset energi konstan, yang evolusi waktunya hanya menambahkan fase global ke circuit, operator bilangan individual yang evolusi waktunya setara dengan rotasi Z satu qubit, serta hasil kali orde lebih tinggi seperti $n_i n_j$. Tidak satu pun dari suku ini dapat mengubah okupansi sebuah mode, sehingga membuangnya tidak mengurangi muatan eksitasi. Berbeda dengan penolakan per-pengambilan di langkah 5, penyaringan ini terjadi sekali, pada Hamiltonian itu sendiri, sehingga distribusi koefisien yang disampel protokol dibangun ulang secara konsisten dari operator yang sudah disaring, bukan dinormalisasi ulang di tengah pengambilan.

Fungsi filter_diagonal_terms() menghapus suku-suku tersebut dari operator secara in place:

PYTHON

>>> from qiskit_fermions.operators.terms.filtering import filter_diagonal_terms
>>>
>>> filter_diagonal_terms(canon)

C

qf_ferm_op_filter_diagonal_terms(canon);

Menyaring di sini, sekali saja, jauh lebih murah daripada menyaring berulang kali. FermionicQDrift berjalan sekali per circuit yang ditranspilasi, jadi menyaring Hamiltonian di awal, bukan di setiap pemanggilan, menghindari pekerjaan berulang untuk setiap circuit yang dihasilkan darinya.

Petunjuk

Karena alasan yang sama, ada baiknya mengurutkan suku-suku Hamiltonian berdasarkan indeks grup di sini. Indeks grup adalah tag per suku yang tidak menyatakan apa pun tentang posisi suku-suku tersebut, sehingga suku-suku sebuah grup pada umumnya tersebar di seluruh operator: pengelompokan yang diterapkan di atas memberi indeks menurut urutan kemunculan pertama, yang membuat suku kedua sebuah grup berada jauh dari suku pertamanya.

FermionicQDrift men-sampel seluruh grup dan mencari setiap grup yang terambil dengan split_out_groups(). Menemukan sebuah grup di antara suku yang tersebar berarti memindai semuanya, sehingga pencarian itu berbiaya sama baik satu grup maupun empat puluh grup yang diambil. group_order() mengumpulkan tiap grup menjadi satu rangkaian yang berurutan, sehingga pencarian menjadi binary search atas batas-batas grup dan berbiaya sebesar grup yang diambil, bukan suku yang dipegang. Pencarian itu sendiri menjadi jauh lebih murah; seberapa banyak hal ini menghemat transpilasi tertentu bergantung pada apa lagi yang dilakukan pipeline, karena mapping dan sintesis mendominasi setelah pemindaian hilang:

PYTHON

>>> from qiskit_fermions.operators.terms.ordering import group_order
>>>
>>> canon = group_order(canon)
>>> print(canon.groups[:4])
[0, 0, ...]

C

QfFermionOperator* grouped = qf_ferm_op_group_order(canon);

Ini mengurutkan ulang suku tanpa mengubah nilai operator, dan hanya perlu dilakukan sekali berapa pun banyaknya randomisasi circuit yang diambil darinya.

3. Siapkan circuit evolusi waktu

Siapkan circuit evolusi waktu Hamiltonian dan circuit dasar tempat sampel diambil. qiskit_fermions.circuit.library berisi semua komponen yang diperlukan untuk itu, sesuai konvensi Qiskit.

Protokol qDRIFT adalah metode sintesis FermionicQDrift, dan gate Evolution membawanya sebagai synthesis-nya. Metode ini memperkenalkan beberapa parameter yang bisa kamu pakai untuk menyesuaikan circuit yang dihasilkan:

• Panjang tiap circuit dalam satuan grup eksitasi: num_groups

• Opsional, seed untuk generator bilangan acak: rng

• Opsional, bobot sampling yang sudah dihitung sebelumnya, jika transpilasi itu sendiri menjadi bottleneck: weights (lihat (Opsional) Hitung bobot sampling di muka di bawah)

Karena metode ini dipegang oleh gate, apa pun yang mendeskripsikan operator gate, seperti bobot tersebut, berada tepat di samping operator itu.

PYTHON

>>> from qiskit_fermions.circuit import FermionicCircuit
>>> from qiskit_fermions.circuit.library import Evolution
>>> from qiskit_fermions.circuit.library.synthesis import FermionicQDrift
>>>
>>> time = 1.0  # you can choose a desired scaling factor here
>>> num_groups = 10
>>> qdrift = FermionicQDrift(num_groups, rng=19)
>>> evo_gate = Evolution(num_modes, canon, time, synthesis=qdrift)
>>>
>>> circ = FermionicCircuit(num_modes)
>>> circ.append(evo_gate, circ.modes)

C

// WARNING: Qiskit's C API does not yet allow us to implement circuits
// with custom gate definitions.

Catatan

Contoh ini tidak menginisialisasi mode fermionik dengan partikel, dan juga tidak mengukur state akhirnya.

4. Transpilasi circuit

Modul qiskit_fermions.transpiler terintegrasi langsung dengan pipeline transpilasi Qiskit, sehingga FermionicCircuit yang dibangun di atas bisa langsung ditranspilasi menjadi QuantumCircuit.

Gunakan pemetaan fermion-ke-qubit jordan_wigner() untuk mengubah Hamiltonian yang dinyatakan dalam fermion menjadi dinyatakan dalam string Pauli. Ini bisa dilakukan langsung sebagai bagian dari proses transpilasi dengan memakai pass transpilasi F2QSynthesis. Gunakan generate_preset_jw_pass_manager() untuk membangun FermionicStagedPassManager, yang memastikan encoding Jordan-Wigner dipakai secara konsisten untuk semua instruksi circuit.

Yang terpenting, tambahkan pass Decompose milik Qiskit ke tahap optimization pada pipeline transpilasi. Pass ini menguraikan gate Evolution dengan metode sintesis yang dibawa gate tersebut, yaitu metode qDRIFT yang disiapkan di atas. Ini memastikan circuit tidak memakai evolusi waktu dari seluruh Hamiltonian, yang kedalamannya akan melebihi kemampuan hardware komputasi kuantum yang tersedia saat ini.

Sebagai gantinya, pass ini men-subsampel sejumlah tetap groups suku Hamiltonian untuk setiap circuit, setiap kali circuit ditranspilasi. Dengan cara ini, kamu bisa menghasilkan beberapa randomisasi circuit seperti yang dibutuhkan algoritma SqDRIFT dengan menjalankan pipeline transpilasi berulang kali. Jumlah circuit yang dihasilkan adalah num_sqdrift_randomizations.

PYTHON

>>> from qiskit.transpiler.passes import Decompose
>>> from qiskit_fermions.transpiler import FermionicPassManager
>>> from qiskit_fermions.transpiler.presets import generate_preset_jw_pass_manager
>>>
>>> pm = generate_preset_jw_pass_manager()
>>> pm.optimization = FermionicPassManager([Decompose(["Evolution"])])
>>>
>>> num_sqdrift_randomizations = 10
>>> sqdrift_circuits = [
...     pm.run(circ) for _ in range(num_sqdrift_randomizations)
... ]

C

// WARNING: Qiskit's C API does not yet allow us to implement circuits
// with custom gate definitions, which we therefore also cannot transpile
// via this API.

Catatan

Contoh-contoh sebelumnya menetapkan seed rng pada metode sintesis FermionicQDrift, sehingga urutan randomisasi bisa direproduksi.

Petunjuk

Pipeline yang sama menerima metode qDRIFT di dua tempat lain. Pass F2FSynthesis menerima satu metode untuk setiap gate Evolution berdasarkan nama, F2FSynthesis({"Evolution": FermionicQDrift(num_groups)}), yang cukup jika tidak ada gate yang memegang sesuatu yang spesifik untuk operatornya. Langkah berikutnya memakai yang ketiga, yaitu pass QDriftTrotterization.

5. Saring eksitasi yang terambil berdasarkan okupansi

Selain suku diagonal yang sudah disaring pada langkah sebelumnya, sebuah eksitasi yang terambil bisa bekerja sepenuhnya dalam sekumpulan mode yang okupansinya sudah tetap (semuanya terisi atau semuanya kosong), di mana eksitasi itu tidak bisa memindahkan partikel dari satu sisi ke sisi lain. Eksitasi seperti itu tidak memberi tahu apa pun tentang bitstring hasil sampling, sehingga slot yang dipakai untuknya terbuang percuma. Pass QDriftTrotterization, yang membungkus metode FermionicQDrift yang sama, menolak eksitasi seperti itu saat terambil dan mengambil penggantinya, sehingga setiap dari num_groups slot pada circuit yang dihasilkan membawa eksitasi yang menghubungkan kedua sisi.

Peringatan

Penyaringan ini tidak gratis, dan karena itulah ia berupa pass terpisah. Yang dihemat adalah anggaran num_groups slot yang disampel, bukan kedalaman circuit: karena anggaran itu tetap, eksitasi yang ditolak diganti, bukan dibuang, dan eksitasi yang murah digantikan oleh eksitasi penghubung yang lebih mahal untuk disintesis. Harapkan circuit yang disaring lebih dalam daripada yang tidak disaring dari seed yang sama.

Menormalisasi ulang pengambilan atas eksitasi yang diterima mengubah distribusi yang disampel protokol qDRIFT, dan tidak seperti pengelompokan di langkah 2, hal ini juga merusak jaminan konvergensi protokol: hasil kali yang disampel tidak lagi rata-rata sama dengan evolusi di bawah Hamiltonian yang kamu berikan. Setiap eksitasi yang dipertahankan akhirnya berbobot kebalikan dari probabilitas penerimaan, yang ditolak tidak berkontribusi apa pun, dan baik total magnitudo koefisien maupun waktu evolusi per gate tidak disesuaikan sebagai kompensasi.

Aturan penerimaan juga merupakan over-approximation. Aturan ini hanya membandingkan support mode, sehingga tidak membawa informasi amplitudo, dan himpunan yang dilacak hanya terus bertambah: eksitasi yang terbatas pada himpunan terisi memang inert pada product state, tetapi penalaran yang sama menjadi lebih lemah untuk pengambilan berikutnya, setelah eksitasi yang diterima sebelumnya membuat state menjadi entangled dan menandai sebagian besar mode sebagai “tidak pasti”.

Gunakan penyaringan ini untuk alur kerja sampling bitstring yang dijelaskan panduan ini, di mana circuit menyuplai post-processing SQD dan hanya bitstring hasil sampling yang penting. Jangan gunakan jika kamu berniat mengestimasi nilai ekspektasi dari circuit ini, atau mengandalkan batas galat qDRIFT dengan cara lain: hasil tersebut membawa bias yang tidak dikoreksi oleh pass ini.

Penyaringan ini perlu tahu mode mana yang awalnya terisi. Karena itu diperlukan gate InitializeModes sebelum gate Evolution di circuit; InitializeModes.from_hartree_fock() adalah cara praktis untuk membuatnya. Tambahkan satu di sini untuk referensi Hartree-Fock N2 (tujuh elektron alpha dan tujuh elektron beta dalam 14 orbital spasial) dan bandingkan eksitasi hasil sampling dengan dan tanpa penyaringan:

PYTHON

>>> from qiskit_fermions.circuit.library import InitializeModes
>>> from qiskit_fermions.transpiler.passes import F2FSynthesis, QDriftTrotterization
>>>
>>> init = InitializeModes.from_hartree_fock(fcidump.norb, (7, 7))
>>>
>>> hf_circ = FermionicCircuit(num_modes)
>>> hf_circ.append(init, hf_circ.modes)
>>> hf_circ.append(Evolution(num_modes, canon, time), hf_circ.modes)
>>>
>>> num_groups = 5
>>> qdrift_unfiltered = F2FSynthesis(
...     {"Evolution": FermionicQDrift(num_groups, rng=3480)}
... )
>>> qdrift_trivial = QDriftTrotterization(
...     FermionicQDrift(num_groups, rng=3480)
... )
>>>
>>> for instruction in FermionicPassManager(qdrift_unfiltered).run(hf_circ)._inner.data:
...     if instruction.operation.name == "Evolution":
...         print(sorted(instruction.operation.operator.get_support()))
[2, 4]
[41, 45, 52]
[15, 45, 55]
[41, 52, 53]
[10, 16, 37, 38]
>>>
>>> for instruction in FermionicPassManager(qdrift_trivial).run(hf_circ)._inner.data:
...     if instruction.operation.name == "Evolution":
...         print(sorted(instruction.operation.operator.get_support()))
[0, 1, 6, 7]
[0, 1, 28, 29]
[4, 13, 55]
[13, 20, 40, 41]
[0, 1, 28, 29]

C

// WARNING: Qiskit's C API does not yet allow us to implement circuits
// with custom gate definitions, which we therefore also cannot transpile
// via this API.

Tidak satu pun eksitasi yang terambil tanpa penyaringan menyentuh himpunan terisi (0-6 dan 28-34) sama sekali, jadi tidak satu pun bisa memindahkan partikel antara mode terisi dan mode kosong. Dengan penyaringan, kelimanya ditolak dan diganti dengan eksitasi yang menghubungkan mode terisi dengan mode kosong. Misalnya, eksitasi pertama yang diterima [0, 1, 6, 7] memindahkan partikel antara mode terisi 0, 1, dan 6 dan mode kosong 7.

Begitu sebuah eksitasi diterima, setiap mode dalam support-nya menjadi “tidak pasti” dan karenanya layak berperan di salah satu sisi untuk sampel berikutnya, sehingga himpunan mode terisi dan kosong terus bertambah seiring makin banyak eksitasi diterima. Inilah yang membuat eksitasi kedua, [0, 1, 28, 29], bisa diterima. Keempat modenya termasuk mode yang semula terisi, jadi ia tidak terhubung ke mode yang semula kosong. Eksitasi ini hanya diterima karena mode 0 dan 1 menjadi tidak pasti (dan karenanya layak menjadi sisi “kosong” dari penghubungan) setelah eksitasi pertama menyentuhnya.

Pertumbuhan ini yang membuat aturan tersebut menjadi over-approximation, bukan sebuah uji: seiring makin banyak mode menjadi tidak pasti, makin sedikit pengambilan yang ditolak, dan penyaringan paling berpengaruh pada distribusi sampling di pengambilan paling awal.

Untuk menilai seberapa jauh penyaringan menggeser distribusi, baca jumlah penolakan yang dicatat pass di metadata circuit. Satu entri disimpan per gate Evolution yang disaring, dan rasio diterima-terhadap-total memperkirakan probabilitas penerimaan, yaitu faktor yang membuat eksitasi yang dipertahankan berbobot berlebih:

PYTHON

>>> # a freshly seeded pass, so the counts do not depend on earlier draws
>>> qdrift_counted = QDriftTrotterization(
...     FermionicQDrift(num_groups, rng=3480)
... )
>>> filtered = FermionicPassManager(qdrift_counted).run(hf_circ)
>>> discarded = filtered.metadata.get("filter_trivial.discarded")
>>> emitted = filtered.metadata.get("filter_trivial.emitted")
>>> print(f"{emitted[0]} kept, {discarded[0]} discarded")
5 kept, 7 discarded
>>> print(f"acceptance probability: {emitted[0] / (emitted[0] + discarded[0]):.2f}")
acceptance probability: 0.42

C

// WARNING: Qiskit's C API does not yet allow us to implement circuits
// with custom gate definitions, which we therefore also cannot transpile
// via this API.

Catatan

Penyaringan memerlukan informasi okupansi sebagai acuan. Gate PrepareSlaterDeterminant menyediakannya sama seperti InitializeModes, dan setiap OrbitalRotation menandai setiap mode yang dikenainya sebagai “tidak pasti”. Tanpa salah satunya, atau ketika semua mode yang diisi berada di satu sisi (semua mode terisi, atau semua mode kosong), pass mengeluarkan UserWarning dan membiarkan sampling tidak disaring untuk gate Evolution tersebut. Pada Hamiltonian yang suku-suku sisanya tidak lagi bisa menghubungkan kedua himpunan yang dilacak, pass justru memunculkan RuntimeError setelah QDriftTrotterization.MAX_SAMPLE_RETRIES penolakan berturut-turut.

(Opsional) Hitung bobot sampling di muka

Gunakan ini hanya jika transpilasi itu sendiri menjadi bottleneck. Ini tidak mengubah apa pun pada circuit yang kamu peroleh.

FermionicQDrift mengambil tiap grup dengan probabilitas sebanding dengan magnitudo koefisiennya, dan menurunkan magnitudo itu dari Hamiltonian pada setiap pemanggilan: satu nilai per suku Hamiltonian, direduksi menjadi satu per grup. Karena metodenya stateless, reduksi itu diulang untuk setiap randomisasi, padahal hasilnya selalu identik. Argumen weights memungkinkan kamu menghitungnya sekali dengan group_coeff_means() dan menyerahkan hasilnya, memindahkan biaya keluar dari loop sambil menjaga metode bebas dari state cache yang bergantung pada Hamiltonian.

Ini adalah pasangan dari pengurutan suku di langkah 2. Yang itu mengangkat pencarian grup keluar dari loop, yang ini mengangkat reduksi bobot, dan masing-masing hanya terasa sejauh yang lain tidak ada, jadi layak menerapkan keduanya sekaligus. Karena canon sudah diurutkan ulang di atas, keduanya bisa langsung digabungkan.

Bobot mendeskripsikan grup dari satu operator tertentu, jadi bobot itu menjadi milik gate Evolution dari operator tersebut: bangun metode untuk gate itu dan serahkan sebagai synthesis gate, persis seperti di langkah 3.

PYTHON

>>> from qiskit_fermions.operators.terms.grouping import group_coeff_means
>>>
>>> weights = group_coeff_means(canon)  # `canon` is group-ordered, from step 2
>>> qdrift_weighted = FermionicQDrift(10, rng=19, weights=weights)
>>> weighted_gate = Evolution(num_modes, canon, time, synthesis=qdrift_weighted)
>>>
>>> weighted_circ = FermionicCircuit(num_modes)
>>> weighted_circ.append(weighted_gate, weighted_circ.modes)
>>>
>>> weighted_circuits = [
...     pm.run(weighted_circ) for _ in range(num_sqdrift_randomizations)
... ]
>>> len(weighted_circuits)
10

C

// WARNING: Qiskit's C API does not yet allow us to implement circuits
// with custom gate definitions, which we therefore also cannot transpile
// via this API.

Karena itu persis bobot yang akan dihitung pass, circuit-nya sama seperti sebelumnya; hanya reduksi berulangnya yang hilang.

Satu entri diharapkan per grup, bukan per suku, kapan pun operator membawa grup, karena operator yang dikelompokkan disampel per grup. Entri harus non-negatif: bobot adalah sebuah magnitudo, karena protokol qDRIFT mendekomposisi $H = \sum_j h_j H_j$ dengan $h_j$ positif, dan tanda sebuah koefisien menjadi bagian $H_j$, di mana pass membacanya langsung dari operator.

Perhatian

Bobot adalah magnitudo absolut, bukan preferensi relatif. Jumlahnya juga menentukan waktu evolusi, jadi mengalikan setiap entri dengan $\gamma$ menyampel dengan cara yang sama tetapi mengevolusi selama $\gamma t$ alih-alih $t$. Memberikan sesuatu selain magnitudo koefisien Hamiltonian itu sendiri karenanya mengubah evolusi mana yang diaproksimasi ansambel, itulah sebabnya ini adalah alat performa dan bukan cara untuk menyetel sampling.

Karena bobot menjadi milik gate yang operatornya mereka deskripsikan, sebuah circuit boleh memuat beberapa gate Evolution, masing-masing dengan bobot operatornya sendiri. Pass QDriftTrotterization dari langkah 5 menghormatinya dengan cara yang sama: ia mengambil sebuah gate dengan FermionicQDrift yang dibawa gate tersebut, dan kembali ke yang dipakai saat pass dibuat untuk gate yang tidak membawa apa pun. Jenis metode sintesis lain pada sebuah gate bukan pernyataan tentang qDRIFT, jadi pass mengabaikannya. Memberikan metode ke sebuah pass berdasarkan nama gate, seperti F2FSynthesis({"Evolution": ...}), menerapkan satu metode ke setiap gate Evolution, sehingga bobot yang diberikan di sana hanya bermakna untuk circuit dengan satu gate saja. Panjang bobot diperiksa terhadap setiap gate tempat bobot itu diterapkan.

(Opsional) Optimalkan pengindeksan mode fermionik

Kamu bisa menambahkan langkah optimisasi ekstra ke pipeline transpilasi yang meminimalkan jarak rentang eksitasi fermionik dengan melabeli ulang indeks mode fermionik. Optimisasi ini diperkenalkan dalam makalah SqDRIFT dan diimplementasikan oleh build_excitation_span_minimization_model(). Optimisasi ini bisa dengan mudah disisipkan ke pipeline transpiler dengan memakai pass RelabelModes:

PYTHON

>>> from pyomo.environ import SolverFactory
>>> from qiskit_fermions.transpiler.passes import RelabelModes
>>>
>>> solver = SolverFactory("appsi_highs")
>>> solver.options["time_limit"] = 10
>>>
>>> qdrift = F2FSynthesis({"Evolution": FermionicQDrift(5, rng=19)})
>>> relabel = RelabelModes(solver=solver)
>>>
>>> pm.optimization = FermionicPassManager([qdrift, relabel])
>>>
>>> relabeled_circ = pm.run(circ)
>>> # if the automatic mode relabeling was successful, the circuit's
>>> # metadata will contain the mode `permutation` information

C

// WARNING: This feature is not available via the C API.

Catatan

Memakai optimisasi otomatis di dalam RelabelModes (yang memanfaatkan build_excitation_span_minimization_model()) membutuhkan dependensi opsional yang dikelola oleh HAS_PYOMO.

Penting

Pelabelan ulang mengubah mode mana yang dibawa sebuah qubit, sehingga diagonalisasi subruang hanya mendapat bitstring yang benar jika hal itu diperhitungkan. Di mana perhitungan itu dilakukan bergantung pada di mana kamu mengukur.

Tambahkan pengukuran ke FermionicCircuit dengan FermionicCircuit.measure_all() sebelum transpilasi, dan tidak ada yang perlu dilakukan: setiap pengukuran menyebut mode yang dibacanya, sehingga pelabelan ulang ikut terbawa dan bitstring hasil sampling diindeks menurut mode aslinya.

Jika kamu mengukur QuantumCircuit hasil transpilasi, bitstring harus diproses lanjut memakai permutation yang tercatat di metadata circuit. Lihat dokumentasi RelabelModes untuk resepnya.

Langkah berikutnya

Setelah berhasil membuat ansambel circuit, kamu bisa men-sampel bitstring darinya. Untuk itu, circuit harus dieksekusi pada hardware. Lihat dokumentasi Qiskit untuk petunjuk lengkap.

Setelah sampel bitstring diperoleh, sampel tersebut bisa dipakai bersama koefisien Hamiltonian untuk melakukan post-processing SQD, seperti dijelaskan di tutorial addon SQD.