Parity Twine Optimizer: Sebuah Fungsi Qiskit oleh ParityQC

Lihat referensi API

catatan

Qiskit Functions adalah fitur eksperimental yang hanya tersedia untuk pengguna IBM Quantum® Premium Plan, Flex Plan, dan On-Prem (melalui IBM Quantum Platform API) Plan. Fitur ini berstatus rilis pratinjau dan dapat berubah sewaktu-waktu.

Ikhtisar

Parity Twine Optimizer memungkinkan pengguna untuk menyelesaikan masalah optimasi dengan komputer kuantum menggunakan metode Parity Twine. Pendekatan ini, yang dibangun di atas Parity Architecture, menggunakan compiler ParityQC untuk meminimalkan jumlah gate dan kedalaman sirkuit yang diperlukan untuk menjalankan algoritma kuantum sambil memperhitungkan konektivitas perangkat.

Pengurangan sumber daya ini memungkinkan penyelesaian masalah optimasi yang relevan dengan industri untuk ukuran yang tidak layak dengan metode transpilasi standar yang berat SWAP. Parity Twine Optimizer mengotomatiskan langkah-langkah transpilasi dan dapat digunakan dengan input pengguna yang minimal.

Pendekatan Parity Twine mengungguli semua metode kompilasi lain dalam hal mengurangi jumlah gate dan kedalaman sirkuit untuk algoritma kuantum seperti quantum approximate optimization algorithm (QAOA) dan quantum Fourier transform (QFT). Dengan mengabstraksikan informasi kuantum dari qubit fisik, interaksi non-lokal diimplementasikan tanpa gate SWAP. Sebagai gantinya, rantai Parity Twine (urutan gate CNOT) secara sistematis mendistribusikan informasi paritas logis antar qubit.

Optimizer menggunakan QAOA untuk meminimalkan energi dari fungsi biaya yang diberikan. QAOA adalah algoritma variasional hibrida kuantum-klasik yang dirancang untuk menyelesaikan masalah optimasi kombinatorial dengan mendekati keadaan dasar (ground state) dari Hamiltonian biaya ($H_C$). Suku pencampuran (mixing) ($H_B$) mendorong transisi antar keadaan untuk mengeksplorasi ruang solusi. Urutan bergantian dari suku-suku ini, dikendalikan oleh parameter $\gamma$ dan $\beta$, mendefinisikan unitary $U(\gamma, \beta) = \Pi_{i=1}^p e^{-i \beta_i H_B} e^{-i \gamma_i H_C}$, yang bekerja pada keadaan awal.

Encoding dari unitary masalah, exp($-i \beta H_C)$), memerlukan encoding dari semua operator rotasi $n$-body logis (exp($-i \beta J_{i,j,...n}Z_iZ_j...Z_n$)). Hal ini dapat dicapai dengan menggunakan generator $n$-body (Parity Twine Networks), yang mengurangi kedalaman sirkuit QAOA dan jumlah gate dua-qubit.

Deskripsi

Input Parity Twine Optimizer terdiri dari masalah optimasi, nama perangkat keras IBM Quantum yang dipilih, dan argumen opsional tambahan untuk menyesuaikan pengaturan transpilasi dan eksekusi perangkat keras. Fungsi optimizer merutekan definisi masalah ke Parity Twine Compiler. Gambar 1 menunjukkan ringkasan alur kerja fungsi.

Masalah optimasi input dipra-proses menjadi Hamiltonian (yang dinormalisasi). Compiler ParityQC kemudian membangun sirkuit ansatz Parity Twine yang diparameterisasi, yang ditranspilasi menjadi ansatz logis yang sesuai dengan native gate set dari perangkat keras yang dipilih.

Parameter sirkuit QAOA dioptimalkan secara klasik menggunakan pendekatan "efficient depth one" dan ditetapkan ke sirkuit yang ditranspilasi. Karena satu putaran QAOA digunakan, parameter $\gamma$ dan $\beta$ yang optimal diperoleh menggunakan pencarian grid pada CPU tanpa perlu optimasi iteratif yang mahal melalui banyak pemanggilan sirkuit. Hal ini sangat meminimalkan runtime QPU yang diperlukan oleh optimizer. Waktu eksekusi per sirkuit sebagian besar ditentukan oleh overhead konstan untuk menjalankan job pada QPU. Dengan parameter sirkuit yang telah ditetapkan, job dikirimkan ke QPU IBM® yang ditentukan.

Hasil mentah kemudian dipascaproses. Langkah ini menggunakan pencarian greedy lokal yang beriterasi secara acak melalui string solusi dan membalikkan nilai bit jika hal ini mengurangi nilai fungsi biaya.

Benchmark

Penafian

Kinerja dapat bergantung pada instance masalah maupun langkah-langkah pemrosesan selanjutnya. Dalam beberapa kasus, sampel klasik dan sampel yang dihasilkan kuantum mungkin mencapai kualitas solusi akhir yang serupa setelah pascapemrosesan yang setara. Oleh karena itu, evaluasi harus mempertimbangkan keseluruhan alur kerja optimasi.

Model Sherrington-Kirkpatrick

Gambar 2 menunjukkan efektivitas Parity Twine Optimizer. Ini membandingkan hasil yang diperoleh menggunakan optimizer dengan sampling acak untuk model Sherrington-Kirkpatrick dengan jumlah qubit yang meningkat.

Pascapemrosesan dari kedua hasil acak dan optimizer menghasilkan keadaan dasar yang eksak, tetapi output energi minimum mentah dari Twine QAOA selalu lebih baik daripada nilai acak. Untuk jumlah qubit terbesar yang dipertimbangkan (90 dan 100), noise perangkat keras menurunkan hasil optimizer sehingga kembali ke nilai mentah yang menyerupai sampling acak.

Lihat tutorial ini untuk pengantar model Sherrington-Kirkpatrick dan rincian tentang cara menyelesaikannya dengan Parity Twine Optimizer.

Masalah Market Split

Tabel 1 menunjukkan metrik performa spesifik untuk Parity Twine Optimizer yang diterapkan pada berbagai instance masalah Market Split (MS). Metrik ini diperoleh dari QOBLIB - Quantum Optimization Benchmarking Library dan sesuai dengan submission yang dibuat ke library menggunakan Parity Twine Optimizer.

MS violation adalah metrik akurasi yang mengukur seberapa jauh solusi belum memenuhi semua batasan, didefinisikan sebagai $\sum_i ((Ax - b)_i)^2$. Nilai yang lebih rendah dari metrik ini menunjukkan solusi yang lebih akurat. Tabel 1 melaporkan nilai rata-rata untuk lima kali eksekusi setiap instance menggunakan Parity Twine Optimizer dengan perangkat ibm_boston sebagai backend dan 100.000 shot. MS violation minimum yang diperoleh dari eksekusi setiap instance dilaporkan.

Instance	Qubit	Gate dua-qubit	Kedalaman dua-qubit	MS violation	Waktu pemetaan (s)	Runtime QPU (s)	Waktu pascaproses (s)
ms_03_050_002	20	399	76	0	45	29	71
ms_03_100_022	20	399	76	0	30	29	77
ms_03_200_177	20	399	76	0	33	29	63
ms_04_050_001	30	899	116	1	68	29	216
ms_04_100_003	30	899	116	2	89	29	187
ms_04_200_030	30	899	116	3	89	29	219
ms_05_100_003	40	1599	156	3	237	30	364
ms_06_050_001	50	2499	196	4	499	30	464
ms_07_050_001	60	3599	236	17	858	31	637
ms_08_050_001	70	4899	276	36	1561	31	773

Tabel 1: Metrik performa untuk berbagai instance masalah market split. Nama instance sesuai dengan contoh yang berkaitan dalam library masalah QOBLIB. Seperti yang disebutkan sebelumnya di bagian deskripsi, waktu QPU minimal dan hampir konstan, karena hanya satu putaran QAOA yang digunakan dengan parameter sirkuit optimal yang diperoleh pada CPU.

Lihat tutorial ini untuk pengantar masalah Market Split dan rincian tentang cara menyelesaikannya dengan Parity Twine Optimizer.

Masalah Maximum Independent Set

Gambar 3 membandingkan hasil yang diperoleh menggunakan optimizer Parity Twine dengan sampling acak untuk masalah maximum independent set pada instance terpilih yang diperoleh dari QOBLIB - Quantum Optimization Benchmarking Library. Instance ini berkisar dari 18 (mammalia-kangaroo-interactions) hingga 114 (es60fst03) qubit.

Untuk instance kecil, hasil ukuran Maximum Independent Set mentah dari optimizer dan sampling acak serupa, tetapi untuk instance yang lebih besar, optimizer memberikan hasil yang jauh lebih baik. Pascapemrosesan dari hasil sampling acak dan optimizer sekali lagi menghasilkan ukuran set yang sesuai dengan nilai eksak.

Mulai

Autentikasi menggunakan token API IBM Quantum Platform Anda dan pilih Fungsi Qiskit sebagai:

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit_ibm_catalog": "qiskit-ibm-catalog"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit_ibm_catalog import QiskitFunctionsCatalog

# Authenticate and load the Qiskit Function
catalog = QiskitFunctionsCatalog(
    channel="ibm_quantum_platform",
)
function = catalog.load("parityqc/parity-twine-optimizer")

Contoh

Parity Twine Optimizer dapat diterapkan pada contoh QUBO sederhana sebagai berikut. Pertama, masalah didefinisikan menggunakan dictionary:

problem = {"()": 3, "(0,)": 1, "(0, 1)": 2, "(1, 2)": -1}

Kemudian, tipe variabel harus didefinisikan sebagai binary atau spin:

variable_type = "spin"

Ini mendefinisikan fungsi objektif $3 + s_0 + 2 s_0s_1 - s_1s_2$ di mana $s_i \in \{-1, 1\}$.

Pilih backend. Contohnya:

backend_name = "ibm_phoenix"

Gunakan catalog.backends() untuk melihat daftar backend yang tersedia dari akun/instance pengguna.

Jika tidak ada backend yang ditentukan, backend yang paling tidak sibuk (yang memiliki jumlah job tertunda paling sedikit) akan dipilih secara otomatis.

Setelah optimizer dimuat (lihat sebelumnya), Anda dapat menjalankannya pada masalah menggunakan opsi default:

function_job = function.run(
    problem=problem, variable_type=variable_type, backend_name=backend_name
)
print(f"Job ID: {function_job.job_id}")

Periksa status job sebagai berikut:

# Monitor the job status
function_job.status()

Ambil hasil sebagai berikut:

# Retrieve the job result if the status is DONE
result = function_job.result()

result

Hasil cetaknya adalah sebagai berikut:

{
    'solution': {'0': -1, '1': 1, '2': 1},
    'objective_value': -1.0,
    'solution_bitstring': '100',
    'metadata': {
        'circuit_metrics': {
            'depth': 20,
            'gate_count': 198,
            'two_qubit_gate_depth': 4,
            'two_qubit_gate_count': 4,
            'num_qubits': 3,
            'operations': {'delay': 158, 'rz': 17, 'sx': 14, 'cz': 4, 'measure': 3, 'x': 2}
        },
        'solver_info': {
            'variable_mapping': {'0': 0, '1': 1, '2': 2},
            'bitstring_distributions': {
                'before_postprocessing': {'100': 71760, ... },
                'after_postprocessing': {'100': 88440, '011': 11560}
            },
            'best_parameters': {
                'beta': [-0.46259546391008877],
                'gamma': [0.6181957189727373]
            }
        },
        'resource_usage': {
            'RUNNING: MAPPING': {'CPU_TIME': 42.878},
            'RUNNING: OPTIMIZING_FOR_HARDWARE': {'CPU_TIME': 0.094},
            'RUNNING: WAITING_FOR_QPU': {'CPU_TIME': 790.623},
            'RUNNING: EXECUTING_QPU': {'QPU_TIME': 28.0},
            'RUNNING: POST_PROCESSING': {'CPU_TIME': 0.828}
        }
    }
}

Dictionary solution sesuai dengan qubit yang didefinisikan dalam masalah ($s_0, s_1$, dan $s_2$) dan memberikan nilai spin yang telah dioptimalkan.

objective_value adalah biaya atau energi dari masalah optimasi. Ini mengukur kualitas solution.

metadata memberikan informasi tentang transpilasi (jumlah/kedalaman gate dua-qubit, gate yang digunakan, qubit aktif) dan berbagai runtime untuk waktu komputasi kuantum maupun klasik.

Selain itu, metadata memberikan gambaran tentang cara kerja internal algoritma. Anda dapat melihat parameter variasional yang dioptimalkan (beta dan gamma) dan meninjau bagaimana distribusi bitstring yang diukur meningkat setelah pascapemrosesan klasik diterapkan pada hasil kuantum mentah.

Semua bitstring dalam output hasil dapat dipetakan ke variabel masalah dengan menggunakan variable_mapping. Sebagai contoh, Anda dapat memetakan 'solution_bitstring': '100' dengan 'variable_mapping': {'0': 0, '1': 1, '2': 2} ke solusi biner: {'0': 1, '1': 0, '2': 0}. Karena Anda menyelesaikan masalah dalam bentuk variabel spin, Anda perlu menerapkan transformasi biner ke spin (0 -> 1, 1 -> -1 ). Anda kemudian sampai pada solusi akhir 'solution': {'0': -1, '1': 1, '2': 1}.

Lihat referensi API untuk rincian lengkap tentang input dan output dari fungsi Parity Twine Optimizer.

Log Perubahan

[1.0.2] - 2026-09-15

Notes

Rilis ini menandai versi produksi stabil pertama dari Fungsi Qiskit Parity Twine Optimizer. Rilis mendatang diharapkan akan memperkenalkan hal-hal berikut:

• kompilasi masalah orde tinggi,
• algoritma optimasi tambahan, dan
• peningkatan dalam prapemrosesan dan pascapemrosesan.

Fitur

• Selesaikan masalah QUBO sparse dan dense dengan Parity Twine Compiler yang efisien.

Dokumentasi

• Panduan memulai untuk pengguna.
• Tutorial dengan contoh untuk masalah Market Split dan Sherrington-Kirkpatrick.
• Dokumentasi API.

Dapatkan dukungan

Hubungi ParityQC untuk pertanyaan atau masalah apa pun.

Langkah berikutnya

Rekomendasi

• Minta akses ke function ini dengan mengisi formulir ini.
• Kunjungi referensi API untuk Qiskit Function ini.
• Coba tutorial untuk menerapkan Parity Twine Optimizer pada masalah Market Split.
• Coba tutorial untuk menerapkan Parity Twine Optimizer pada model Sherrington-Kirkpatrick.
• Lihat preprint ArXiv Connectivity-aware Synthesis of Quantum Algorithms, Drier et al. (2025).