Mitigasi error dengan IBM Circuit function

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 masih dalam status rilis pratinjau dan dapat berubah sewaktu-waktu.

Estimasi penggunaan: 26 menit pada prosesor Eagle (CATATAN: Ini hanya estimasi. Waktu aktual mungkin berbeda.)

Tutorial ini membahas contoh membangun dan menjalankan workflow menggunakan IBM Circuit function. Fungsi ini menerima Primitive Unified Blocs (PUB) sebagai input dan mengembalikan nilai ekspektasi yang sudah dimitigasi errornya sebagai output. Fungsi ini menyediakan pipeline otomatis dan tersesuaikan untuk mengoptimalkan Circuit dan menjalankannya di hardware kuantum, sehingga para peneliti bisa fokus pada penemuan algoritma dan aplikasi.

Kunjungi dokumentasi untuk pengenalan Qiskit Functions dan pelajari cara memulai dengan IBM Circuit function.

Latar Belakang

Tutorial ini membahas Circuit evolusi waktu Trotterisasi yang efisien untuk hardware model Ising medan transversal 2D secara umum, dan menghitung magnetisasi global. Circuit seperti ini berguna di berbagai domain aplikasi seperti fisika materi terkondensasi, kimia, dan machine learning. Untuk informasi lebih lanjut tentang struktur model ini, lihat Nature 618, 500–505 (2023).

IBM Circuit function menggabungkan kemampuan dari layanan transpiler Qiskit dan Qiskit Runtime Estimator untuk menyediakan antarmuka yang lebih sederhana dalam menjalankan Circuit. Fungsi ini melakukan transpilasi, penekanan error, mitigasi error, dan eksekusi Circuit dalam satu layanan terkelola, sehingga kita bisa fokus pada pemetaan masalah ke Circuit tanpa harus membangun setiap langkah pola secara manual.

Persyaratan

Sebelum memulai tutorial ini, pastikan kamu sudah menginstal hal-hal berikut:

Qiskit SDK v1.2 atau lebih baru (pip install qiskit)
Qiskit Runtime v0.28 atau lebih baru (pip install qiskit-ibm-runtime)
IBM Qiskit Functions Catalog client v0.0.0 atau lebih baru (pip install qiskit-ibm-catalog)
Qiskit Aer v0.15.0 atau lebih baru (pip install qiskit-aer)

Setup

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-ibm-catalog qiskit-ibm-runtime rustworkx

import rustworkx
from collections import defaultdict
from numpy import pi, mean

from qiskit_ibm_runtime import QiskitRuntimeService

from qiskit_ibm_catalog import QiskitFunctionsCatalog

from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.quantum_info import SparsePauliOp

Langkah 1: Memetakan input klasik ke masalah kuantum

Input: Parameter untuk membuat Circuit kuantum
Output: Circuit abstrak dan observable

Membangun Circuit

Circuit yang akan kita buat adalah Circuit evolusi waktu Trotterisasi yang efisien untuk hardware model Ising medan transversal 2D. Kita mulai dengan memilih Backend. Properti Backend ini (yaitu coupling map-nya) akan digunakan untuk mendefinisikan masalah kuantum dan memastikannya efisien untuk hardware.

service = QiskitRuntimeService()
backend = service.least_busy(
    operational=True, simulator=False, min_num_qubits=127
)

Selanjutnya, kita ambil coupling map dari Backend.

coupling_graph = backend.coupling_map.graph.to_undirected(multigraph=False)
layer_couplings = defaultdict(list)

Kita perlu berhati-hati dalam merancang layer Circuit kita. Kita akan melakukan ini dengan mewarnai edge dari coupling map (yaitu, mengelompokkan edge yang tidak saling terhubung) dan menggunakan pewarnaan itu untuk menempatkan Gate di Circuit secara lebih efisien. Ini akan menghasilkan Circuit yang lebih dangkal dengan layer Gate yang bisa dieksekusi secara bersamaan di hardware.

edge_coloring = rustworkx.graph_bipartite_edge_color(coupling_graph)

for edge_idx, color in edge_coloring.items():
    layer_couplings[color].append(
        coupling_graph.get_edge_endpoints_by_index(edge_idx)
    )
layer_couplings = [
    sorted(layer_couplings[i]) for i in sorted(layer_couplings.keys())
]

Selanjutnya, kita tulis fungsi helper sederhana yang mengimplementasikan Circuit evolusi waktu Trotterisasi yang efisien untuk hardware model Ising medan transversal 2D menggunakan pewarnaan edge yang diperoleh di atas.

def construct_trotter_circuit(
    num_qubits: int,
    num_trotter_steps: int,
    layer_couplings: list,
    barrier: bool = True,
) -> QuantumCircuit:
    theta, phi = Parameter("theta"), Parameter("phi")
    circuit = QuantumCircuit(num_qubits)

    for _ in range(num_trotter_steps):
        circuit.rx(theta, range(num_qubits))
        for layer in layer_couplings:
            for edge in layer:
                if edge[0] < num_qubits and edge[1] < num_qubits:
                    circuit.rzz(phi, edge[0], edge[1])
        if barrier:
            circuit.barrier()

    return circuit

Kita akan memilih jumlah Qubit dan langkah trotter, lalu membangun Circuit-nya.

num_qubits = 100
num_trotter_steps = 2

circuit = construct_trotter_circuit(
    num_qubits, num_trotter_steps, layer_couplings
)
circuit.draw("mpl", fold=-1)

Output of the previous code cell

Untuk membandingkan kualitas eksekusi, kita perlu membandingkannya dengan hasil ideal. Circuit yang dipilih ini melampaui kemampuan simulasi klasik brute force. Jadi, kita tetapkan parameter semua Gate Rx di Circuit ke $0$ , dan parameter semua Gate Rzz ke $\pi$ . Ini membuat Circuit menjadi Clifford, yang memungkinkan simulasi ideal dan mendapatkan hasil ideal untuk perbandingan. Dalam kasus ini, kita tahu hasilnya adalah 1.0.

parameters = [0, pi]

Membangun observable

Pertama, hitung magnetisasi global sepanjang $\hat{z}$ untuk masalah $N$ -Qubit: $M_z = \sum_{i=1}^N \langle Z_i \rangle / N$ . Ini memerlukan penghitungan magnetisasi satu situs $\langle Z_i \rangle$ untuk setiap Qubit $i$ terlebih dahulu, yang didefinisikan dalam kode berikut.

observables = []
for i in range(num_qubits):
    obs = "I" * (i) + "Z" + "I" * (num_qubits - i - 1)
    observables.append(SparsePauliOp(obs))

print(observables[0])

SparsePauliOp(['ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII'],
              coeffs=[1.+0.j])

Langkah 2 dan 3: Mengoptimalkan masalah untuk eksekusi hardware kuantum dan menjalankan dengan IBM Circuit function

Input: Circuit abstrak dan observable
Output: Nilai ekspektasi yang dimitigasi

Sekarang, kita bisa mengoper Circuit abstrak dan observable ke IBM Circuit function. Fungsi ini akan menangani transpilasi dan eksekusi di hardware kuantum untuk kita dan mengembalikan nilai ekspektasi yang telah dimitigasi. Pertama, kita muat fungsinya dari IBM Qiskit Functions Catalog.

catalog = QiskitFunctionsCatalog(
    token="<YOUR_API_KEY>"
)  # Use the 44-character API_KEY you created and saved from the IBM Quantum Platform Home dashboard
function = catalog.load("ibm/circuit-function")

IBM Circuit function menerima pubs, backend_name, serta input opsional untuk mengonfigurasi transpilasi, mitigasi error, dan lain-lain. Kita buat pub dari Circuit abstrak, observable, dan parameter Circuit. Nama Backend harus ditentukan sebagai string.

pubs = [(circuit, observables, parameters)]
backend_name = backend.name

Kita juga bisa mengonfigurasi options untuk transpilasi, penekanan error, dan mitigasi error. Pengaturan default akan digunakan jika kita tidak ingin menentukannya. IBM Circuit function hadir dengan opsi yang umum digunakan untuk optimization_level, yang mengontrol seberapa banyak optimasi Circuit yang dilakukan, dan mitigation_level, yang menentukan seberapa banyak penekanan dan mitigasi error yang diterapkan. Perlu diperhatikan bahwa mitigation_level dari IBM Circuit function berbeda dari resilience_level yang digunakan di Qiskit Runtime Estimator. Untuk deskripsi lengkap opsi yang umum digunakan serta opsi lanjutan lainnya, kunjungi dokumentasi IBM Circuit function.

Dalam tutorial ini, kita akan menetapkan default_precision, optimization_level: 3 dan mitigation_level: 3, yang akan mengaktifkan gate twirling dan Zero Noise Extrapolation (ZNE) melalui Probabilistic Error Amplification (PEA) di atas pengaturan level 1 default.

options = {
    "default_precision": 0.011,
    "optimization_level": 3,
    "mitigation_level": 3,
}

Dengan input yang sudah ditentukan, kita kirimkan job ke IBM Circuit function untuk optimasi dan eksekusi.

job = function.run(backend_name=backend_name, pubs=pubs, options=options)

Langkah 4: Pasca-proses dan kembalikan hasil dalam format klasik yang diinginkan

Input: Hasil dari IBM Circuit function
Output: Magnetisasi global

Menghitung magnetisasi global

Hasil dari menjalankan fungsi ini memiliki format yang sama dengan Estimator.

result = job.result()[0]

Kita dapatkan nilai ekspektasi yang dimitigasi dan yang tidak dimitigasi dari hasil ini. Nilai ekspektasi ini merepresentasikan magnetisasi satu situs sepanjang arah $\hat{z}$ . Kita rata-ratakan ini untuk mendapatkan magnetisasi global dan membandingkannya dengan nilai ideal 1.0 untuk instance masalah ini.

mitigated_expvals = result.data.evs
magnetization_mitigated = mean(mitigated_expvals)

print("mitigated:", magnetization_mitigated)

unmitigated_expvals = [
    result.data.evs_extrapolated[i][0][1] for i in range(num_qubits)
]
magnetization_unmitigated = mean(unmitigated_expvals)

print("unmitigated:", magnetization_unmitigated)

mitigated: 0.9749883476088692
unmitigated: 0.7832977198447583

Survei tutorial

Silakan isi survei singkat ini untuk memberikan masukan tentang tutorial ini. Pendapatmu akan membantu kami meningkatkan konten dan pengalaman pengguna.

Link to survey

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.

Source: IBM Quantum docs — updated 27 Apr 2026

English version on doQumentation — updated 7 Mei 2026

This translation based on the English version of 9 Apr 2026

Latar Belakang​

Persyaratan​

Setup​

Langkah 1: Memetakan input klasik ke masalah kuantum​

Membangun Circuit​

Membangun observable​

Langkah 2 dan 3: Mengoptimalkan masalah untuk eksekusi hardware kuantum dan menjalankan dengan IBM Circuit function​

Langkah 4: Pasca-proses dan kembalikan hasil dalam format klasik yang diinginkan​

Menghitung magnetisasi global​

Survei tutorial​