IBM on kenji.blog

Pengantar Super Pemrograman Kuantum dengan Qiskit

Fri, 11 Sep 2026 20:00:00 +0900

1. Pendahuluan

Komputer modern (komputer klasik) telah secara dramatis mengubah kehidupan kita dan mendukung berbagai aspek masyarakat dengan kemampuan komputasi yang canggih. Namun, untuk beberapa masalah tertentu (seperti faktorisasi bilangan prima yang sangat besar, simulasi struktur molekul yang kompleks, masalah optimasi, dll.), diketahui bahwa bahkan superkomputer paling canggih saat ini pun akan membutuhkan waktu lebih lama daripada usia alam semesta.

Yang memiliki potensi untuk mendobrak “keterbatasan komputer klasik” ini adalah Komputer Kuantum (Quantum Computer). Dengan memanfaatkan sifat-sifat aneh mekanika kuantum (superposisi dan keterikatan kuantum) sebagai sumber daya komputasi, diyakini bahwa masalah-masalah tertentu dapat dipercepat secara dramatis.

Dalam artikel ini, kita akan mengambil langkah pertama ke dunia pemrograman kuantum menggunakan Qiskit, sebuah kerangka kerja komputasi kuantum sumber terbuka yang disediakan oleh IBM. Ini adalah panduan pengantar yang sangat rinci yang menjelaskan secara saksama dari dasar-dasar fisika dan matematika, hingga proses penulisan kode dengan Python dan menjalankan sirkuit kuantum di simulator.

2. Dasar-dasar Fisika dan Matematika yang Mendukung Komputasi Kuantum

Untuk memahami pemrograman kuantum, pertama-tama kita perlu memahami konsep dasar mekanika kuantum. Di sini, kita akan menjelaskan tiga pilar penting: qubit, superposisi, dan keterikatan kuantum.

2.1 Bit Klasik dan Qubit (Quantum bit)

Unit informasi komputer klasik adalah “Bit”. Sebuah bit selalu mengambil salah satu dari dua keadaan, 0 atau 1.

Di sisi lain, unit minimum informasi dalam komputer kuantum disebut Qubit (Quantum bit). Qubit tidak hanya dapat mengambil keadaan 0 dan 1, tetapi juga dapat mempertahankan kedua keadaan tersebut secara bersamaan.

Secara matematis, keadaan qubit $|\psi\rangle$ direpresentasikan sebagai kombinasi linear (superposisi) dari keadaan basis $|0\rangle$ dan $|1\rangle$.

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

Di sini, $\alpha$ dan $\beta$ adalah bilangan kompleks, masing-masing merepresentasikan amplitudo probabilitas untuk mengamati keadaan $|0\rangle$ dan $|1\rangle$. Berdasarkan prinsip dasar mekanika kuantum, jumlah total probabilitas harus sama dengan 1, sehingga memenuhi kondisi normalisasi berikut:

$$ |\alpha|^2 + |\beta|^2 = 1 $$

graph LR A["Bit Klasik (Classical Bit)"] --> B["Keadaan pasti: 0 atau 1"] C["Qubit (Quantum bit)"] --> D["Superposisi: 0 dan 1 sekaligus"] D --> E["Keadaan ditentukan secara probabilistik melalui pengukuran"]

2.2 Superposisi (Superposition)

Seperti yang disebutkan sebelumnya, keadaan di mana status $|0\rangle$ dan $|1\rangle$ bercampur disebut Superposisi (Superposition).

Misalnya, ketika satu qubit berada dalam keadaan superposisi yang benar-benar seimbang, $\alpha = \frac{1}{\sqrt{2}}$, $\beta = \frac{1}{\sqrt{2}}$.

$$ |\psi\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle $$

Jika kita mengukur keadaan ini, $|0\rangle$ dan $|1\rangle$ masing-masing akan diamati dengan probabilitas 50%. Jika ada 2 qubit, kita dapat membuat superposisi dari 4 keadaan: $|00\rangle, |01\rangle, |10\rangle, |11\rangle$. Jika ada $n$ qubit, $2^n$ keadaan dapat direpresentasikan secara bersamaan, yang merupakan salah satu sumber kemampuan pemrosesan paralel komputer kuantum.

2.3 Keterikatan Kuantum (Entanglement)

Sifat paling kuat dan misterius dalam komputasi kuantum adalah Keterikatan Kuantum (Entanglement). Fenomena yang disebut Einstein sebagai “aksi seram dari kejauhan” ini adalah sifat di mana dua atau lebih qubit sangat terkait satu sama lain, sedemikian rupa sehingga ketika keadaan salah satu qubit ditentukan, keadaan qubit lainnya akan langsung ditentukan pula secara instan, tidak peduli seberapa jauh jarak fisiknya.

Salah satu “Keadaan Bell (Bell State)”, yang merupakan keadaan keterikatan kuantum paling terkenal, keadaan $\Phi^+$ dinyatakan sebagai berikut:

$$ |\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}} $$

Dalam keadaan ini, status $|01\rangle$ dan $|10\rangle$ tidak ada. Oleh karena itu, jika qubit pertama diukur dan hasilnya $|0\rangle$, bahkan tanpa mengukur qubit kedua, sudah pasti hasilnya adalah $|0\rangle$. Sebaliknya, jika qubit pertama $|1\rangle$, maka yang kedua juga pasti $|1\rangle$.

3. Gerbang Logika Kuantum (Quantum Logic Gates)

Sama seperti komputer klasik yang menggunakan gerbang logika seperti AND, OR, dan NOT untuk melakukan komputasi, komputer kuantum juga menggunakan gerbang kuantum untuk memanipulasi keadaan qubit. Karena keadaan kuantum adalah vektor, gerbang kuantum direpresentasikan sebagai “matriks uniter” yang bekerja pada vektor tersebut.

3.1 Gerbang Pauli (Pauli-X, Y, Z)

Gerbang Pauli adalah operasi dasar pada 1 qubit.

・Gerbang Pauli-X (Gerbang NOT) Setara dengan gerbang NOT klasik. Membalikkan $|0\rangle$ menjadi $|1\rangle$, dan $|1\rangle$ menjadi $|0\rangle$. (Rotasi 180 derajat di sekitar sumbu X pada bola Bloch)

$$ X = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix} $$

・Gerbang Pauli-Y Melakukan rotasi 180 derajat di sekitar sumbu Y. Memiliki efek membalikkan fase dan bit.

$$ Y = \begin{pmatrix} 0 & -i \\ i & 0 \end{pmatrix} $$

・Gerbang Pauli-Z (Gerbang pembalikan fase) Membiarkan keadaan $|0\rangle$ tetap sama, tetapi membalikkan fase keadaan $|1\rangle$ (mengalikan dengan $-1$). (Rotasi 180 derajat di sekitar sumbu Z)

$$ Z = \begin{pmatrix} 1 & 0 \\ 0 & -1 \end{pmatrix} $$

3.2 Gerbang Hadamard (Hadamard Gate)

Gerbang Hadamard (gerbang H) adalah gerbang yang sangat penting yang mengubah keadaan pasti ($|0\rangle$ atau $|1\rangle$) menjadi keadaan superposisi.

$$ H = \frac{1}{\sqrt{2}} \begin{pmatrix} 1 & 1 \\ 1 & -1 \end{pmatrix} $$

Menerapkan gerbang H pada $|0\rangle$ menghasilkan keadaan superposisi seimbang $|+\rangle$.

$$ H|0\rangle = \frac{1}{\sqrt{2}}|0\rangle + \frac{1}{\sqrt{2}}|1\rangle = |+\rangle $$

3.3 Gerbang Fase (Phase Gates)

Gerbang fase adalah bentuk umum dari gerbang Z, yang memutar fase keadaan $|1\rangle$ sebesar sudut $\theta$ yang ditentukan.

$$ P(\theta) = \begin{pmatrix} 1 & 0 \\ 0 & e^{i\theta} \end{pmatrix} $$

Contoh tipikalnya adalah gerbang S ($\theta = \pi/2$) dan gerbang T ($\theta = \pi/4$).

3.4 Gerbang CNOT (Controlled-NOT Gate)

Gerbang CNOT (gerbang CX) adalah gerbang yang beroperasi di antara dua qubit dan sangat penting untuk menghasilkan keterikatan kuantum. Terdiri dari “bit kontrol (Control bit)” dan “bit target (Target bit)”.

Hanya ketika bit kontrol adalah $|1\rangle$, gerbang X (operasi NOT) diterapkan pada bit target, dan tidak ada yang dilakukan jika bit kontrol adalah $|0\rangle$.

$$ CNOT = \begin{pmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ 0 & 0 & 1 & 0 \end{pmatrix} $$

4. Dasar-dasar Qiskit dan Penyiapan Lingkungan

Mulai dari sini, kita akan benar-benar menulis program kuantum menggunakan Python dan Qiskit.

4.1 Apa itu Qiskit?

Qiskit adalah kit pengembangan perangkat lunak (SDK) komputasi kuantum sumber terbuka yang dikembangkan oleh IBM Quantum. Anda dapat membangun sirkuit kuantum secara intuitif menggunakan Python dan menjalankannya pada simulator lokal atau komputer kuantum riil IBM melalui cloud.

4.2 Cara Menginstal

Lingkungan Python diperlukan untuk menggunakan Qiskit. Instal Qiskit dan paket terkait (simulator dan pustaka visualisasi) menggunakan perintah berikut.

1

pip install qiskit qiskit-aer qiskit-ibm-runtime matplotlib pylatexenc

4.3 Alur Dasar Pemrograman

Pemrograman kuantum dengan Qiskit pada dasarnya dilanjutkan dengan langkah-langkah berikut.

graph TD A["1. Membangun Sirkuit (Build)"] --> B["2. Kompilasi/Transpilasi (Compile)"] B --> C["3. Eksekusi (Execute)"] C --> D["4. Analisis dan Visualisasi Hasil (Analyze)"]

Membangun Sirkuit: Buat objek QuantumCircuit dan tambahkan gerbang.
Kompilasi: Optimalkan sirkuit untuk backend target (mesin nyata atau simulator).
Eksekusi: Kirim pekerjaan (job) ke backend dan dapatkan hasilnya.
Analisis: Plot histogram hasil pengukuran, dsb.

5. Praktik: Membangun Sirkuit untuk Membuat Keadaan Bell (Keterikatan Kuantum)

Mari kita coba membuat “Keterikatan Kuantum (Keadaan Bell)” yang telah kita pelajari secara teori menggunakan Qiskit. Keadaan targetnya adalah $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$.

5.1 Desain Sirkuit

Untuk membuat keadaan Bell, ikuti langkah-langkah berikut:

Siapkan dua qubit (keadaan awal keduanya adalah $|0\rangle$).
Terapkan gerbang Hadamard (H) ke qubit pertama untuk membuatnya menjadi keadaan superposisi.
Terapkan gerbang CNOT dengan menetapkan qubit pertama sebagai “bit kontrol” dan qubit kedua sebagai “bit target”.
Lakukan pengukuran (Measure) untuk membaca hasilnya.

5.2 Implementasi Kode Python/Qiskit

Mari kita lihat kode yang sebenarnya.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit_aer import Aer
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt

# 1. Inisialisasi Sirkuit
# Buat sirkuit kuantum dengan 2 qubit dan 2 bit klasik
qc = QuantumCircuit(2, 2)

# 2. Penerapan Gerbang H
# Terapkan gerbang Hadamard pada qubit 0 (q0)
qc.h(0)

# 3. Penerapan Gerbang CNOT
# Terapkan CNOT dengan q0 sebagai bit kontrol dan q1 sebagai bit target
qc.cx(0, 1)

# 4. Pengukuran
# Ukur qubit 0 dan 1, lalu tulis hasilnya ke bit klasik 0 dan 1 secara berurutan
qc.measure([0, 1], [0, 1])

# Menggambar diagram sirkuit (menggunakan matplotlib)
# qc.draw('mpl')
print(qc.draw())

Saat Anda menjalankan kode ini, diagram sirkuit kuantum dalam seni ASCII akan ditampilkan di konsol seperti berikut.

1
2
3
4
5
6
7


 ┌───┐ ┌─┐
q_0: ┤ H ├──■──┤M├───
 └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
 └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
 0 1

H mewakili gerbang Hadamard, kombinasi ■ dan X adalah gerbang CNOT, dan M mewakili pengukuran.

5.3 Eksekusi di Simulator dan Interpretasi Hasil

Selanjutnya, kita akan menjalankan sirkuit ini di simulator berkinerja tinggi Aer milik IBM dan memeriksa hasilnya.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


# Dapatkan backend simulator Aer
simulator = Aer.get_backend('qasm_simulator')

# Transpilasi (optimasi) sirkuit untuk simulator
compiled_circuit = transpile(qc, simulator)

# Eksekusi sirkuit (di sini menjalankan 1000 tembakan/shots)
job = simulator.run(compiled_circuit, shots=1000)

# Dapatkan hasilnya
result = job.result()

# Dapatkan jumlah frekuensi pengamatan keadaan (counts)
counts = result.get_counts(compiled_circuit)
print("\nHasil pengukuran:", counts)

# Plot histogram
# plot_histogram(counts)
# plt.show()

Interpretasi Hasil

Output konsol seharusnya terlihat seperti ini: Hasil pengukuran: {'00': 495, '11': 505} (*Karena probabilitasnya bersifat acak, angkanya akan sedikit bervariasi pada setiap eksekusi)

Dalam lingkungan simulasi yang ideal, hasil pengukuran 00 dan 11 masing-masing akan diamati sekitar 50% probabilitas, sementara 01 dan 10 tidak akan pernah diamati sama sekali. Ini sepenuhnya sesuai dengan prediksi teoretis dari keadaan Bell $|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}$ yang telah kita buat. Ini mensimulasikan “keterikatan kuantum” secara akurat, di mana jika qubit pertama bernilai 0, maka yang kedua pasti 0, dan jika bernilai 1, maka yang kedua juga pasti 1.

Namun perlu dicatat, jika dijalankan pada komputer kuantum riil (IBM Quantum Hardware), sedikit kemunculan 01 atau 10 mungkin teramati karena pengaruh gangguan/noise (dekoherensi kuantum dan kesalahan gerbang). Bagaimana cara mengurangi noise ini (Koreksi Kesalahan Kuantum) adalah salah satu tantangan terbesar dalam pengembangan komputer kuantum saat ini.

6. Peningkatan Skala ke Algoritma yang Lebih Lanjut

Membuat keadaan Bell dapat disebut sebagai “Hello World” dari pemrograman kuantum. Dengan mengembangkannya lebih jauh dari sini, kita dapat membangun algoritma tangguh yang melampaui komputer klasik.

6.1 Algoritma Deutsch-Jozsa

Ini adalah masalah untuk menentukan apakah sebuah fungsi $f(x)$ yang diberikan adalah “fungsi konstan (selalu menghasilkan 0 atau selalu menghasilkan 1 terlepas dari inputnya)” atau “fungsi seimbang (menghasilkan 0 untuk setengah input, dan 1 untuk setengah sisanya)”. Dalam komputer klasik, pada kasus terburuk membutuhkan evaluasi fungsi sebanyak $2^{n-1} + 1$ kali. Namun, dengan menggunakan Algoritma Deutsch-Jozsa, hal ini dapat ditentukan hanya dengan 1 evaluasi dengan memanfaatkan paralelisme kuantum. Hal ini menunjukkan pola dasar algoritma kuantum, yaitu memasukkan keadaan superposisi, memanfaatkan interferensi (Interference) untuk membatalkan keadaan yang tidak diinginkan, dan memperkuat jawaban yang diinginkan.

6.2 Algoritma Grover

Dalam masalah pencarian data tertentu dari basis data tidak terurut yang berisi $N$ elemen, algoritma klasik rata-rata membutuhkan $N/2$ perhitungan, sedangkan Algoritma Grover dapat menemukan data target dalam $\sqrt{N}$ kali pencarian. Algoritma ini menggunakan kotak hitam yang disebut “Oracle” untuk membalikkan fase solusi target, dan kemudian melakukan “Amplifikasi Amplitudo (Amplitude Amplification)” untuk secara dramatis meningkatkan probabilitas ditemukannya solusi target.

graph TD A["Inisialisasi (Superposisi semua keadaan)"] --> B["Oracle (Membalikkan fase jawaban yang benar)"] B --> C["Operator difusi (Amplifikasi amplitudo dengan membalikkan di sekitar nilai rata-rata)"] C --> D{"Apakah probabilitas yang cukup telah tercapai?"} D -- "Tidak" --> B D -- "Ya" --> E["Pengukuran"]

7. Kesimpulan dan Pembelajaran Selanjutnya

Dalam artikel ini, kita telah secara rinci menjelaskan mulai dari konsep dasar komputasi kuantum seperti superposisi dan keterikatan kuantum, hingga pengoperasian gerbang logika kuantum menggunakan Qiskit, serta proses membangun, menyimulasikan, dan menginterpretasikan keadaan Bell yang sesungguhnya.

Karena Qiskit dapat ditulis dalam bahasa Python yang sudah familier, Qiskit adalah alat kuat yang memungkinkan kita untuk melampaui batasan matematis/fisika dan fokus pada membangun algoritma. Komputer kuantum saat ini berada di era perangkat kuantum skala menengah yang ber-noise (NISQ: Noisy Intermediate-Scale Quantum), tetapi penelitian terapan di berbagai bidang seperti Pembelajaran Mesin Kuantum (Quantum Machine Learning), Simulasi Kimia (Quantum Chemistry), dan Kriptanalisis sedang berkembang pesat di seluruh dunia.

Dengan segala cara, silakan gunakan Qiskit untuk membuat berbagai sirkuit kuantum Anda sendiri dan jalankan pada prosesor perangkat keras riil IBM Quantum. Anda pasti akan dapat mengalami langsung paradigma komputasi masa depan.

Referensi

Dokumentasi Resmi Qiskit
Buku Teks Qiskit - Teks resmi yang direkomendasikan bagi mereka yang ingin mempelajari latar belakang matematika dan algoritma lebih dalam
IBM Quantum Learning

Selamat datang di dunia kuantum!

Apa itu Keunggulan Kuantum? Tren Terbaru dari Google dan IBM

Fri, 11 Sep 2026 18:00:00 +0900

1. Pendahuluan: Fajar Komputasi Kuantum dan “Keunggulan Kuantum”

Komputasi kuantum memiliki potensi untuk memecahkan masalah kompleks yang tidak dapat diselesaikan dalam waktu yang realistis oleh komputer klasik (PC dan superkomputer yang biasa kita gunakan sehari-hari) dengan mengaplikasikan mekanika kuantum, prinsip fundamental fisika, ke dalam pemrosesan informasi. Bidang ini telah lama didominasi oleh penelitian teoritis, tetapi dalam beberapa tahun terakhir, kemajuan pesat pada perangkat keras telah mengintensifkan persaingan menuju penerapan praktis.

Salah satu kata kunci yang paling banyak menarik perhatian dalam hal ini adalah “Keunggulan Kuantum (Quantum Supremacy)”. Ini merujuk pada momen ketika komputer kuantum menunjukkan kemampuan komputasi yang melampaui komputer klasik dalam tugas komputasi tertentu. Dalam artikel ini, kita akan membahas secara rinci, dari definisi ketat tentang keunggulan kuantum, detail eksperimen dari prosesor “Sycamore” Google yang diumumkan sebagai yang pertama di dunia mencapai tonggak sejarah ini pada tahun 2019, sanggahan dan pendekatan unik dari IBM terhadap hal tersebut, hingga peta jalan terbaru menuju “Koreksi Kesalahan Kuantum (Quantum Error Correction: QEC)” dan “Komputasi Kuantum Toleran Kesalahan (Fault-Tolerant Quantum Computing: FTQC)”, yang merupakan hambatan terbesar menuju penerapan praktis yang sesungguhnya, sembari menggali lebih dalam dari sisi teknis dan matematis.

2. Latar Belakang Teoritis: Dasar Komputasi Kuantum dan Kelas Kompleksitas

Untuk memahami keunggulan kuantum, pertama-tama kita perlu memahami dasar matematis komputasi kuantum dan posisinya dalam teori kompleksitas komputasi.

Qubit dan Superposisi

Unit informasi terkecil dalam komputer klasik adalah bit (0 atau 1), sedangkan komputer kuantum menggunakan qubit (Quantum bit). Keadaan 1 qubit $|\psi\rangle$ direpresentasikan oleh kombinasi linear kompleks dari keadaan basis $|0\rangle$ dan $|1\rangle$.

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

Di sini, $\alpha, \beta \in \mathbb{C}$, dan memenuhi kondisi normalisasi $|\alpha|^2 + |\beta|^2 = 1$. Sifat ini disebut “Superposisi (Superposition)”.

Keterikatan (Entanglement) dan Produk Tensor

Ketika ada beberapa qubit, keadaan sistem secara keseluruhan direpresentasikan oleh produk tensor dari ruang keadaan masing-masing qubit. Sistem $n$ qubit akan menjadi vektor dalam ruang Hilbert berdimensi $2^n$ $\mathcal{H}^{\otimes n}$.

$$ |\Psi\rangle = \sum_{x \in \{0, 1\}^n} c_x |x\rangle $$

Di sini, $\sum |c_x|^2 = 1$. Keadaan di mana qubit tidak independen dan keadaan yang satu bergantung pada keadaan yang lain disebut “Keterikatan Kuantum (Quantum Entanglement)”. Hal ini memberikan komputer kuantum potensi untuk memproses ruang keadaan yang sangat luas yang meningkat secara eksponensial dalam waktu yang bersamaan.

Definisi Teoritis Kompleksitas Komputasi dari Keunggulan Kuantum

Dalam teori kompleksitas komputasi, kelas masalah yang dapat diselesaikan secara efisien (dalam waktu polinomial) oleh komputer klasik disebut BPP (Bounded-error Probabilistic Polynomial time). Di sisi lain, kelas masalah yang dapat diselesaikan secara efisien oleh komputer kuantum adalah BQP (Bounded-error Quantum Polynomial time).

Mendemonstrasikan keunggulan kuantum berarti “menjalankan tugas tertentu yang termasuk dalam BQP tetapi tidak termasuk dalam BPP (atau kemungkinannya sangat tinggi) pada perangkat keras kuantum nyata, dan mengungguli simulasi oleh superkomputer klasik dari segi waktu dan sumber daya.” Hal ini dapat dikatakan sebagai upaya bersejarah untuk menyangkal Tesis Church-Turing yang diperluas (“semua model komputasi yang dapat diwujudkan secara fisik dapat disimulasikan secara efisien dalam waktu polinomial oleh mesin Turing probabilistik”) melalui eksperimen fisik.

3. Tahun 2019: Demonstrasi Keunggulan Kuantum oleh Google

Pada bulan Oktober 2019, tim Google Quantum AI mengumumkan di jurnal ilmiah “Nature” bahwa mereka telah mencapai keunggulan kuantum menggunakan prosesor superkonduktor 53-qubit bernama “Sycamore”.

Arsitektur Prosesor Sycamore

Prosesor Sycamore terdiri dari 54 qubit superkonduktor tipe Transmon yang disusun dalam kisi 2 dimensi (hanya 53 yang digunakan dalam eksperimen karena 1 mengalami kerusakan fungsi). Coupler yang dapat disesuaikan (Tunable Coupler) ditempatkan di antara qubit yang berdekatan untuk merealisasikan gerbang 2-qubit yang cepat dan berpresisi tinggi (hibrida dari gerbang iSWAP dan gerbang kontrol Z).

graph TD A["Input Algoritma Kuantum"] --> B["Prosesor Sycamore (53 Qubit)"] B --> C["Terapkan Gerbang Kuantum Acak"] C --> D["Ukur Keadaan Kuantum (Bitstring)"] D --> E["Benchmarking Entropi Silang (XEB)"] E --> F["Verifikasi Keunggulan Kuantum"]

Pengambilan Sampel Sirkuit Kuantum Acak (Random Circuit Sampling: RCS)

Tugas yang dipilih oleh Google adalah “Pengambilan Sampel Sirkuit Kuantum Acak”. Ini melibatkan penerapan gerbang 1-qubit dan 2-qubit yang dipilih secara acak selama beberapa siklus (kedalaman $m$), lalu mengukur keadaan akhir untuk mengambil sampel dari distribusi probabilitas string bit yang dihasilkan.

Probabilitas bitstring $x$ yang dihasilkan dari sirkuit kuantum acak yang ideal (tanpa noise) bukanlah distribusi seragam, melainkan menunjukkan pola mirip pita interferensi yang disebut distribusi Porter-Thomas. Untuk mengambil sampel dari distribusi ini dengan komputer klasik, diperlukan simulasi dari seluruh vektor keadaan, di mana kompleksitas komputasinya meningkat secara eksponensial terhadap jumlah qubit $n$ dan kedalaman sirkuit $m$.

Evaluasi Fidelitas (Fidelity): Benchmarking Entropi Silang Linear (XEB)

Untuk membuktikan bahwa hasil eksperimen bukan sekadar noise melainkan hasil dari perhitungan kuantum yang sebenarnya, Google menggunakan Benchmarking Entropi Silang Linear (Linear Cross-Entropy Benchmarking: XEB). Probabilitas ideal $P(x_i)$ dari sirkuit untuk bitstring $x_i$ yang diperoleh dalam eksperimen dihitung dengan komputer klasik, dan fidelitas $\mathcal{F}_{\text{XEB}}$ dicari menggunakan rumus berikut.

$$ \mathcal{F}_{\text{XEB}} = 2^n \langle P(x_i) \rangle_{i} - 1 $$

Jika $\mathcal{F}_{\text{XEB}}$ bernilai 0, maka itu adalah noise murni, dan jika 1, itu berarti prosesor kuantum ideal tanpa noise. Prosesor Sycamore mencapai $\mathcal{F}_{\text{XEB}} \approx 0.002$ (0,2%) pada sirkuit dengan kedalaman 20. Meski sekilas tampak rendah, nilai ini secara statistik lebih besar dari nol secara signifikan, dan merupakan pencapaian luar biasa dalam mengendalikan ruang keadaan sebesar $2^{53} \approx 9 \times 10^{15}$.

Tingkat kesalahan keseluruhan dimodelkan secara perkiraan sebagai produk dari kesalahan gerbang individual, kesalahan pengukuran, dan lain-lain.

$$ \mathcal{F} \approx (1 - e_1)^{N_1}(1 - e_2)^{N_2} \cdots \approx \prod_{g \in 1Q} (1 - e_g) \prod_{g \in 2Q} (1 - e_g) \prod_{q} (1 - e_{RO}) $$

(Keterangan: $e_g$ adalah kesalahan gerbang, $e_{RO}$ adalah kesalahan pengukuran)

Google mengklaim bahwa butuh sekitar 10.000 tahun bagi superkomputer klasik (Summit) untuk menyimulasikan sirkuit ini. Sebaliknya, Sycamore menyelesaikan pengambilan sampel hanya dalam 200 detik.

4. Sanggahan IBM: Dari “Keunggulan” Menjadi “Kegunaan (Utility)”

Pengumuman Google mengejutkan seluruh dunia, tetapi IBM, pengembang superkomputer terbesar di dunia “Summit” dan pelopor dalam pengembangan komputer kuantum itu sendiri, segera mempublikasikan makalah yang menyanggah klaim tersebut.

Peningkatan Simulasi Klasik melalui Kontraksi Jaringan Tensor

Inti dari sanggahan IBM adalah bahwa “optimalisasi algoritma dan sumber daya pada sisi komputer klasik masih belum cukup”. Google mendasarkan perkiraan 10.000 tahun pada simulator vektor keadaan yang secara langsung menghitung evolusi waktu dari persamaan Schrödinger, tetapi IBM menunjukkan bahwa waktu simulasi dapat dipersingkat secara drastis dengan menggunakan metode yang disebut “Jaringan Tensor (Tensor Network)”.

Dalam jaringan tensor, operasi gerbang sirkuit kuantum direpresentasikan sebagai operasi array multidimensi (tensor), dan urutan “kontraksi (Contraction)” jaringan dioptimalkan. Lebih jauh lagi, mereka mengklaim bahwa dengan memanfaatkan sepenuhnya penyimpanan masif Summit yang mencapai 250 PB (hierarki disk dan memori), simulasi berpresisi lebih tinggi dapat diselesaikan hanya dalam “dua setengah hari” dengan tetap menyimpan seluruh vektor keadaan.

Quantum Advantage dan Quantum Utility

Perdebatan ini memicu pergeseran tren di seluruh industri, dari kebiasaan terpaku pada “melakukan tugas buatan yang mustahil dilakukan secara klasik (Supremacy)” menjadi “menunjukkan keunggulan praktis yang nyata di atas pendekatan klasik pada masalah dunia nyata yang berguna (Quantum Advantage)”, dan bahkan menuju fase di mana “komputer kuantum berfungsi sebagai alat baru untuk penemuan ilmiah (Quantum Utility)”.

IBM sendiri menghindari penggunaan istilah “keunggulan” dan mengusulkan “Volume Kuantum (Quantum Volume)” serta “CLOPS (Circuit Layer Operations Per Second)” sebagai metrik kinerja komprehensif dari prosesor kuantum, dan mendorong pengembangan yang berfokus pada keseimbangan antara skala dan kualitas perangkat keras.

timeline title "Evolusi Tonggak Sejarah Kuantum" 2019 : "Google Sycamore (53Q)" : "Pengumuman Keunggulan Kuantum" 2019 : "Sanggahan IBM" : "Simulasi superkomputer Summit dalam 2,5 hari" 2021 : "IBM Eagle (127Q)" : "Menembus batas 100 qubit" 2022 : "IBM Osprey (433Q)" : "Meningkatkan skala prosesor" 2023 : "Surface Code Google" : "Menskalakan koreksi kesalahan (d=3 ke d=5)" 2023 : "Quantum Utility IBM" : "Simulasi model spin kompleks pada 127Q" 2024 : "Seterusnya" : "Era Qubit Logis dan Mitigasi Kesalahan"

5. Frontier Selanjutnya: Mitigasi Kesalahan (Error Mitigation) dan Koreksi Kesalahan Kuantum (QEC)

Komputer kuantum saat ini disebut “NISQ (Noisy Intermediate-Scale Quantum)”, rentan terhadap pengaruh noise (kesalahan karena ketidaksempurnaan kontrol atau interaksi dengan lingkungan eksternal), dan hasilnya akan tenggelam dalam noise jika komputasi panjang dilakukan. Pendekatan untuk mengatasi masalah ini secara garis besar terbagi menjadi dua: “Mitigasi Kesalahan (Error Mitigation)” dan “Koreksi Kesalahan Kuantum (Quantum Error Correction)”.

Mitigasi Kesalahan (Error Mitigation)

Mitigasi kesalahan adalah teknik menghilangkan efek noise dari nilai yang diharapkan dari hasil komputasi melalui pemrosesan akhir klasik tanpa mengubah perangkat keras kuantum. Pada tahun 2023, IBM memadukan prosesor “Eagle” 127 qubit dengan teknik mitigasi kesalahan seperti “Ekstrapolasi Nol-Noise (Zero-Noise Extrapolation: ZNE)” untuk mencapai akurasi yang melampaui metode jaringan tensor hampiran paling mutakhir dalam simulasi evolusi waktu dari model Ising kompleks, dengan mendemonstrasikan “Quantum Utility (Kegunaan Kuantum)”.

Koreksi Kesalahan Kuantum (QEC) dan Qubit Logis

Namun, untuk pada akhirnya menjalankan algoritma kompleks apa pun (misalnya algoritma faktorisasi Shor atau komputasi kimia kuantum yang kompleks), mitigasi kesalahan saja tidak cukup, dan “Koreksi Kesalahan Kuantum (QEC)”, yang secara dinamis mendeteksi dan memperbaiki kesalahan, mutlak diperlukan.

Pendekatan QEC yang paling umum adalah “Kode Permukaan (Surface Code)”. Ini adalah metode di mana beberapa qubit fisik (qubit data) ditempatkan dalam kisi dua dimensi, dan qubit pengukuran (qubit ancilla) ditempatkan di antara mereka untuk terus-menerus menjalankan pengecekan paritas yang disebut “Stabilizer”.

graph LR Q1["Qubit Data (Data)"] --- M1["Ukur X Stabilizer (Ancilla)"] Q2["Qubit Data (Data)"] --- M1 Q3["Qubit Data (Data)"] --- M2["Ukur Z Stabilizer (Ancilla)"] Q4["Qubit Data (Data)"] --- M2 M1 --> EC["Dekode Sindrom Kesalahan (Klasik)"] M2 --> EC EC --> LQ["Pembaruan Keadaan Qubit Logis"]

Teorema Ambang Batas (Threshold Theorem) dan Jarak $d$

Ada “Teorema Ambang Batas” dalam koreksi kesalahan kuantum. Jika tingkat kesalahan qubit fisik $p$ jatuh di bawah ambang batas tertentu $p_{th}$ (sekitar 1% untuk Surface Code), maka tingkat kesalahan logis $p_L$ dapat diturunkan secara eksponensial dengan meningkatkan jarak kode (Distance) $d$ (mengalokasikan lebih banyak qubit fisik ke dalam satu qubit logis).

Persamaan hampiran untuk tingkat kesalahan logis dinyatakan sebagai berikut:

$$ p_L \approx \Lambda \left( \frac{p}{p_{th}} \right)^{\frac{d+1}{2}} $$

Di sini, $\Lambda$ adalah konstanta. Jika $p < p_{th}$, semakin besar $d$, maka semakin kecil $p_L$. Namun, jika $p > p_{th}$, menambahkan lebih banyak qubit fisik justru akan mengakumulasi noise, dan tingkat kesalahan logis akan memburuk.

Tonggak Sejarah Google 2023: Demonstrasi Pengurangan Kesalahan dengan Memperluas Jarak

Pada Februari 2023, Google menerbitkan makalah monumental di jurnal “Nature”. Menggunakan prosesor Sycamore generasi ke-3, mereka menjadi yang pertama di dunia mendemonstrasikan bahwa saat jarak Surface Code diperluas dari $d=3$ (menggunakan 17 qubit fisik) menjadi $d=5$ (menggunakan 49 qubit fisik), tingkat kesalahan logis sedikit turun dari 3,028% menjadi 2,914%.

Ini berarti bahwa mereka telah melangkah ke wilayah $p < p_{th}$, dan mengindikasikan bahwa pembuktian konsep (Proof of Concept) yang paling penting menuju FTQC telah diselesaikan: bahwa kinerja akan meningkat seiring dengan penambahan qubit fisik.

6. Peta Jalan dan Prospek Menuju FTQC (Komputasi Kuantum Toleran Kesalahan)

Google dan IBM sama-sama terlibat dalam persaingan pengembangan yang sengit menuju tujuan akhir FTQC (Fault-Tolerant Quantum Computing), meskipun masing-masing mengambil arsitektur dan pendekatan yang berbeda.

Pendekatan IBM: Modularisasi dan Kisi Heavy-Hex

Sejalan dengan usahanya untuk secara drastis menurunkan tingkat kesalahan, IBM juga fokus untuk menskalakan prosesornya. Sambil menantang batas-batas chip tunggal dengan “Eagle (127Q)”, “Osprey (433Q)”, dan “Condor (1121Q)”, IBM juga mengumumkan arsitektur modular yang disebut “Quantum System Two”. Selain itu, untuk topologi pengikatan antar qubit, mereka menggunakan “Kisi Heavy-Hex” guna mengurangi crosstalk yang tak diinginkan serta meningkatkan stabilitas. Strategi IBM adalah pendekatan hibrida: mengejar kegunaan dalam jangka pendek melalui mitigasi kesalahan mutakhir sambil secara bertahap memperkenalkan QEC.

Pendekatan Google: Peningkatan Kualitas Qubit Logis

Strategi Google lebih menekankan pada penurunan tingkat kesalahan satu qubit logis serendah mungkin (misalnya menurunkannya menjadi $10^{-6}$) daripada meningkatkan jumlah qubit fisik secara drastis. Berangkat dari titik tersebut, Google berupaya memapankan teknologi interkoneksi kuantum (Quantum Interconnects) untuk mentransfer keadaan kuantum antar modul, membidik sistem skala besar di mana ribuan hingga puluhan ribu qubit fisik dapat beroperasi secara paralel.

Implementasi protokol untuk menjalankan gerbang non-Clifford dengan toleransi kesalahan, seperti penyulingan keadaan ajaib (Magic State Distillation), juga akan menjadi rintangan teknologi utama di masa mendatang. Untuk menjalankan algoritma Shor praktis dan memecahkan enkripsi RSA 2048-bit, kabarnya dibutuhkan ribuan qubit logis dengan tingkat kesalahan $10^{-8}$ atau lebih rendah, yang setara dengan jutaan hingga puluhan juta qubit fisik, menandakan bahwa perjalanan masih panjang.

7. Penutup

“Keunggulan Kuantum” adalah tonggak penting dalam sejarah komputer kuantum yang secara fisik membuktikan potensi teoritis dari mesin komputasi. Demonstrasi tahun 2019 oleh Google dan sanggahan konstruktif oleh IBM mendorong seluruh industri dari sekadar pembuktian teoritis menuju pencarian kegunaan (Utility) praktis, dan ke era rekayasa nyata yang diarahkan pada komputasi kuantum toleran kesalahan (FTQC).

Saat ini kita sedang menyaksikan periode transisi dari perangkat NISQ yang penuh noise ke perangkat qubit logis yang dilengkapi koreksi kesalahan. Dalam beberapa tahun hingga satu dekade ke depan, penemuan baru dalam ilmu material, revolusi dalam proses penemuan obat, dan terobosan dalam masalah optimisasi akan menjadi kenyataan seiring dengan evolusi perangkat keras kuantum ini.

Kita harus terus mengawasi pergerakan dari Google, IBM, dan para peneliti di seluruh dunia yang sedang membentuk ilmu komputasi masa depan.