Python 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!

Simulasi Algoritma Shor dengan Python

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

1. Pendahuluan: Krisis Kriptografi yang Dibawa oleh Komputer Kuantum

Sebagian besar keamanan dalam masyarakat internet modern bergantung pada kriptografi kunci publik (terutama enkripsi RSA). Saat kita mengirimkan informasi kartu kredit saat berbelanja online, atau bertukar data yang sangat rahasia, konten komunikasi tersebut dilindungi dengan kuat oleh enkripsi RSA.

Dasar keamanan enkripsi RSA bergantung pada fakta matematis bahwa “memfaktorkan bilangan bulat raksasa ke dalam faktor prima sangat sulit dilakukan oleh komputer klasik (PC atau superkomputer yang biasa kita gunakan)”. Namun, “Algoritma Shor (Shor’s Algorithm)” yang dipublikasikan oleh Peter Shor pada tahun 1994, meruntuhkan asumsi ini dari dasarnya. Terbukti secara matematis bahwa jika Algoritma Shor dijalankan pada komputer kuantum skala besar, faktorisasi prima yang akan memakan waktu lebih lama dari usia alam semesta pada komputer klasik, dapat diselesaikan hanya dalam beberapa menit hingga beberapa jam.

Dalam artikel ini, kami akan menjelaskan secara detail dan menyeluruh tentang bagaimana Algoritma Shor ini melakukan faktorisasi prima dengan cepat, mulai dari mekanisme matematisnya hingga implementasi simulasi konkret menggunakan Python dan framework komputasi kuantum Qiskit.

2. Perubahan Drastis dalam Kompleksitas Komputasi: Dari Fungsi Eksponensial ke Waktu Polinomial

Mengapa faktorisasi prima itu sulit? Bahkan jika kita menggunakan “General Number Field Sieve (GNFS)”, yang dikenal sebagai algoritma faktorisasi prima terbaik di komputer klasik, kompleksitas komputasinya menjadi sub-eksponensial.

Kompleksitas waktu yang dibutuhkan untuk memfaktorkan bilangan komposit dengan $N$ digit menggunakan metode klasik adalah sebagai berikut:

$$ O\left(\exp\left( c (\log N)^{1/3} (\log \log N)^{2/3} \right)\right) $$

Oleh karena itu, hanya dengan memperpanjang ukuran kunci (misalnya, menjadi 2048 bit atau 4096 bit), dekripsi di komputer klasik akan memakan waktu yang tidak realistis seperti ribuan atau puluhan ribu tahun.

Namun, ketika Algoritma Shor digunakan pada komputer kuantum, kompleksitas komputasinya berkurang secara drastis menjadi waktu polinomial terhadap jumlah bit input $\log N$.

$$ O((\log N)^3) $$

Ini berarti bahwa jika jumlah bit digandakan, waktu komputasi pada komputer klasik akan meningkat secara astronomis, sedangkan pada komputer kuantum, waktu komputasi paling banyak hanya akan meningkat sekitar 8 kali lipat. Pengurangan kelas kompleksitas dari waktu eksponensial ke waktu polinomial (inklusi ke dalam kelas BQP) inilah yang merupakan kehebatan sesungguhnya dari Algoritma Shor.

graph TD A["Peningkatan ukuran input (jumlah bit) N"] --> B{"Pemilihan Algoritma"} B -->|Klasik: General Number Field Sieve| C["Peningkatan sub-eksponensial O(exp(...))"] B -->|Kuantum: Algoritma Shor| D["Waktu polinomial O((log N)^3)"] C --> E["Ribuan hingga miliaran tahun (Tidak dapat didekripsi)"] D --> F["Beberapa menit hingga jam (Didekripsi dalam waktu realistis)"]

3. Gambaran Keseluruhan Algoritma dan Latar Belakang Matematis

Algoritma Shor sebenarnya tidak melakukan semuanya di komputer kuantum. Ia dibangun atas kerja sama antara pra-pemrosesan dan pasca-pemrosesan oleh komputer klasik, dan bagian inti (algoritma pencarian periode) oleh komputer kuantum.

Alur keseluruhan algoritma adalah sebagai berikut:

graph TD A["Input: Bilangan komposit N yang ingin difaktorkan"] --> B["Pilih bilangan acak a sehingga a < N"] B --> C{"gcd(a, N) > 1 ?"} C -- "Yes" --> D["Outputkan faktor trivial gcd(a, N) dan selesai"] C -- "No" --> E["Temukan periode r dari f(x) = a^x mod N dengan algoritma kuantum"] E --> F{"r genap DAN a^(r/2) ≢ -1 mod N ?"} F -- "No" --> B F -- "Yes" --> G["Hitung faktor p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N)"] G --> H["Output: p, q"]

Reduksi dari Faktorisasi Prima ke Masalah Pencarian Periode

Ide jenius Shor terletak pada mengubah “masalah faktorisasi prima” menjadi “masalah pencarian periode (Order Finding Problem)”.

Misalkan bilangan bulat $N$ (bilangan yang ingin difaktorkan) dan bilangan bulat coprime $a$ ($1 < a < N$). Kita mendefinisikan fungsi eksponensial modular sebagai berikut:

$$ f(x) = a^x \bmod N $$

Fungsi ini memiliki suatu periode $r$. Dengan kata lain, untuk sembarang $x$, berlaku $f(x+r) = f(x)$. Khususnya saat $x=0$,

$$ a^r \equiv 1 \pmod N $$

Bilangan bulat positif terkecil $r$ yang memenuhi hal ini disebut “order dari $a$ modulo $N$”. Jika kita dapat menemukan periode $r$ ini, kita dapat memperoleh faktor primanya dengan cara berikut.

Dengan mengubah bentuk persamaannya,

$$ a^r - 1 \equiv 0 \pmod N $$

Jika $r$ adalah bilangan genap, kita dapat memfaktorkannya menggunakan rumus selisih kuadrat:

$$ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $$

Ini berarti bahwa $N$ memiliki pembagi persekutuan dengan $(a^{r/2} - 1)$ atau $(a^{r/2} + 1)$ (dengan syarat kondisi $a^{r/2} \not\equiv -1 \pmod N$ terpenuhi). Oleh karena itu, dengan menggunakan Algoritma Euclidean (Euclidean algorithm),

$$ p = \gcd(a^{r/2} - 1, N) $$ $$ q = \gcd(a^{r/2} + 1, N) $$

Jika kita menghitung ini, kita dapat menemukan faktor non-trivial $p, q$ dari $N$. Perhitungan ini (perhitungan faktor persekutuan terbesar dan pembangkitan bilangan acak) dapat dilakukan dengan sangat cepat oleh komputer klasik. Masalahnya menyempit pada bagaimana menemukan periode $r$ ini dengan cepat. Pada komputer klasik, menemukan periode $r$ itu sendiri membutuhkan waktu yang eksponensial. Di sinilah komputer kuantum berperan.

4. Bagian Algoritma Kuantum: Mekanisme Pencarian Periode

Subrutin untuk menemukan periode $r$ menggunakan komputer kuantum terdiri dari 4 langkah berikut.

graph LR subgraph "Transisi Keadaan Kuantum" S1["|0⟩|0⟩ (Inisialisasi)"] --> S2["Gerbang H: Superposisi Σ|x⟩|0⟩"] S2 --> S3["Oracle U: Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT: Ekstraksi periode melalui interferensi"] S4 --> S5["Pengukuran: Dapatkan nilai hampiran y"] end

Langkah 1: Inisialisasi Register Kuantum dan Superposisi

Pertama, kita siapkan dua register kuantum. Register pertama adalah untuk menginput keadaan, dan register kedua adalah untuk menyimpan hasil perhitungan fungsi. Keadaan awal semuanya adalah $|0\rangle$.

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

Terapkan gerbang Hadamard (Hadamard Gate) pada semua qubit di register pertama untuk menciptakan keadaan superposisi probabilitas yang sama untuk semua kemungkinan input $x$ (dari $0$ hingga $Q-1$, dengan $Q=2^n$).

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |0\rangle_2 $$

Dengan ini, komputer kuantum akan secara bersamaan menahan keadaan untuk semua $Q$ input dalam satu operasi. Ini adalah sumber kekuatan yang tangguh dari paralelisme kuantum.

Langkah 2: Penerapan Fungsi Oracle (Eksponensial Modular)

Selanjutnya, dengan menggunakan sirkuit operasi kuantum $U_f$, kita menghitung fungsi $f(x) = a^x \bmod N$ dan menyimpan hasilnya di register kedua.

$$ |\psi_2\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |a^x \bmod N\rangle_2 $$

Pada titik ini, register pertama dan register kedua berada dalam keadaan quantum entanglement (keterikatan kuantum). Jika (seandainya) kita mengukur register kedua dan mendapatkan nilai tertentu $k = a^{x_0} \bmod N$, maka keadaan register pertama akan runtuh (collapse) ke keadaan superposisi dari $x$ yang memberikan nilai $k$ tersebut. Karena periode fungsi adalah $r$, keadaan yang tersisa akan menjadi nilai yang melompat-lompat dengan rentang $r$, yaitu $x_0, x_0+r, x_0+2r, \dots$.

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

Namun, kita tidak ingin mengetahui $x_0$, melainkan ingin mengetahui periode $r$ itu sendiri. Tidak mungkin mengamati $r$ secara langsung dari keadaan ini. Oleh karena itu, kita menggunakan Transformasi Fourier Kuantum.

Langkah 3: Interferensi Fase melalui Transformasi Fourier Kuantum (QFT)

Terapkan Transformasi Fourier Kuantum (Quantum Fourier Transform, QFT) ke register pertama. QFT adalah versi kuantum dari Transformasi Fourier Diskrit klasik dan mengubah amplitudo vektor keadaan. Aksi QFT pada keadaan basis $|x\rangle$ didefinisikan sebagai berikut:

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

Di mana, $\omega = e^{2\pi i / Q}$.

Saat QFT diterapkan, amplitudo keadaan mengalami interferensi. Meskipun detail matematisnya dihilangkan, ketika QFT diterapkan pada keadaan dengan periode $r$, gelombang akan menghasilkan interferensi konstruktif (Constructive Interference) hanya pada saat $y$ adalah nilai yang sangat dekat dengan kelipatan bilangan bulat dari $Q/r$. Keadaan lainnya akan saling meniadakan amplitudo probabilitasnya akibat interferensi destruktif (Destructive Interference) dan mendekati nol.

Langkah 4: Pengukuran dan Ekspansi Pecahan Berlanjut

Terakhir, ukur register pertama. Nilai $y$ yang diperoleh melalui pengukuran akan memenuhi kondisi berikut dengan probabilitas tinggi:

$$ y \approx c \frac{Q}{r} \implies \frac{y}{Q} \approx \frac{c}{r} $$

(di mana $c$ adalah bilangan bulat tak diketahui antara $0 \le c < r$)

Dengan menerapkan algoritma klasik Ekspansi Pecahan Berlanjut (Continued Fraction Expansion) pada bilangan rasional $y/Q$ yang diperoleh, kita menghitung pecahan hampiran $c/r$ dan mengekstrak periode $r$ dari penyebutnya.

5. Implementasi Simulasi Menggunakan Python dan Qiskit

Hanya dengan teori mungkin kurang terasa nyata, jadi mari kita simulasikan Algoritma Shor secara langsung menggunakan Python dan framework komputasi kuantum milik IBM, Qiskit.

Di sini, kita akan mengimplementasikan skenario paling klasik dan terkenal, yaitu “Memfaktorkan $N=15$ menggunakan $a=7$”.

Persiapan Lingkungan Eksekusi

Pastikan Anda telah menginstal Qiskit sebelumnya.

1

pip install qiskit qiskit-aer numpy

Keseluruhan Kode Implementasi Python

Kode berikut adalah contoh implementasi Algoritma Shor khusus untuk $N=15, a=7$. Karena menyusun sirkuit eksponensial modular umum terlalu tinggi biaya komputasinya pada simulator saat ini, logika operasi gerbang di-hardcode untuk kasus khusus $a=7$.

 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
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. Fungsi untuk membangun Transformasi Fourier Kuantum Balikan (QFT†)
def qft_dagger(n):
 """Menghasilkan sirkuit Transformasi Fourier Kuantum Balikan (Inverse QFT) dengan n qubit"""
 qc = QuantumCircuit(n)
 # Gerbang SWAP untuk membalikkan urutan
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # Penerapan gerbang fase terkendali (controlled phase) dan gerbang H
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. Fungsi untuk membangun operasi eksponensial modular terkendali untuk 7^x mod 15
def c_amod15(a, power):
 """Menghasilkan gerbang U terkendali untuk a dan pangkat tertentu (khusus N=15)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # Logika hardcode untuk 7^x mod 15 dalam kasus a=7
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. Komposisi sirkuit kuantum utama
def shor_circuit(a, n_count):
 # n_count: Jumlah bit pada register kendali (control register)
 # Register target (target register) memiliki 4 bit untuk merepresentasikan 0 hingga 15
 qc = QuantumCircuit(n_count + 4, n_count)

 # Inisialisasi register pertama (register kendali) (pembangkitan superposisi)
 for q in range(n_count):
 qc.h(q)

 # Inisialisasi register kedua (register target) menjadi |1> (0001)
 qc.x(3 + n_count)

 # Penerapan operasi eksponensial modular terkendali (Oracle)
 for q in range(n_count):
 # Menerapkan operasi 2^q pangkat
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # Terapkan Transformasi Fourier Kuantum Balikan (Inverse QFT) pada register pertama
 qc.append(qft_dagger(n_count), range(n_count))

 # Mengukur register pertama
 qc.measure(range(n_count), range(n_count))
 return qc

# --- Bagian Eksekusi ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # Menggunakan 8 qubit untuk register kendali (Q=256)

 print(f"Pengaturan Pencarian: N={N}, a={a}, Jumlah qubit kendali={n_count}")

 # Menghasilkan sirkuit
 qc = shor_circuit(a, n_count)

 # Eksekusi di simulator
 sim = AerSimulator()
 # transpile direkomendasikan pada versi Qiskit terbaru
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\nHasil Pengukuran (String bit: Jumlah observasi):")
 for bitstring, count in counts.items():
 print(f" {bitstring}: {count} kali")

 # Pasca-pemrosesan klasik: Penentuan periode r melalui ekspansi pecahan berlanjut
 print("\n--- Perhitungan Periode dan Faktorisasi Prima ---")
 phases = []
 for output in counts:
 # Konversi string bit menjadi desimal
 decimal = int(output, 2)
 # Fase = Nilai pengukuran / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # Dapatkan pecahan hampiran melalui ekspansi pecahan berlanjut. Batas atas penyebut adalah N=15
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"Nilai observasi: {decimal:3d} | Fase: {phase:.4f} | Pecahan berlanjut: {frac} | Perkiraan periode r = {r}")

 # Periksa apakah periode r genap dan memberikan hasil yang valid
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => Berhasil! Faktor prima dari {N} adalah {guess1} dan {guess2}.")
 else:
 print(f" => Hanya faktor trivial. Coba lagi.")
 else:
 print(f" => Gagal karena periode ganjil.")

Penjelasan Kode dan Analisis Hasil Eksekusi

Saat Anda menjalankan kode di atas, sebagai hasil pengukuran dari register kendali, probabilitas tinggi akan menunjukkan puncak (nilai observasi) tertentu. Untuk n_count=8 ($Q=256$), jika menggunakan komputer kuantum ideal (atau simulator), angka seperti 0, 64, 128, dan 192 akan muncul sebagai nilai observasi dengan probabilitas yang sangat besar.

Jika kita membaginya dengan $Q=256$, fase $y/Q$ masing-masing akan menjadi $0.0$, $0.25$, $0.5$, dan $0.75$. Jika fase ini diekspansi menjadi pecahan berlanjut:

$0.25 \to 1/4$ (Perkiraan periode $r=4$)
$0.50 \to 1/2$ (Perkiraan periode $r=2$)
$0.75 \to 3/4$ (Perkiraan periode $r=4$)

Menggunakan periode $r=4$ yang didapatkan di sini, kita dapat menghitung faktor primanya. Karena $a=7, r=4$, $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

Dengan mengesankan, kita berhasil memfaktorkan $15 = 3 \times 5$.

[!TIP] Jika nilai yang diperoleh sebagai ukuran adalah $y=128$ (fase $0.5$), penyebutnya menjadi $2$, dan kita malah mendapatkan pembagi dari periode alih-alih periode sebenarnya $r=4$. Dalam kasus seperti ini, Anda dapat menjalankan algoritma beberapa kali atau memeriksa kelipatan dari $r$ yang diperoleh untuk menemukan periode sebenarnya.

6. Tantangan menuju Penerapan Praktis dan Keterbatasan di Era NISQ

Meskipun memfaktorkan $N=15$ di simulator cukup mudah dilakukan, namun pada kenyataannya, masih banyak hambatan yang dihadapi oleh komputer kuantum nyata untuk memfaktorkan RSA-2048 (angka desimal 617 digit) yang digunakan dalam dunia nyata.

Era di mana kita hidup saat ini disebut sebagai Era NISQ (Noisy Intermediate-Scale Quantum). Qubit sangat rentan terhadap gangguan dari lingkungan eksternal dan dapat mengalami “decoherence” di tengah komputasi, yang merusak keadaan kuantum.

Untuk menjalankan sirkuit yang dalam (jumlah gerbang banyak) seperti pada Algoritma Shor dengan akurat, Koreksi Kesalahan Kuantum (Quantum Error Correction) sangat mutlak diperlukan untuk memperbaiki noise. Untuk menciptakan satu “logical qubit” (qubit logis) yang bebas dari noise, diperlukan ribuan “physical qubit” (qubit fisik) yang dienkode menggunakan teknik seperti Surface Code.

Diperkirakan untuk mematahkan enkripsi RSA 2048-bit, ribuan qubit logis yang sempurna akan diperlukan, dan untuk mewujudkan hal ini, dibutuhkan komputer kuantum fault-tolerant (tahan kesalahan) yang dilengkapi dengan jutaan hingga puluhan juta qubit fisik. Karena prosesor kuantum paling mutakhir saat ini hanya memiliki sekitar ratusan hingga ribuan qubit fisik, sistem kriptografi di seluruh dunia tidak akan serta-merta ditembus dalam waktu dekat.

[!WARNING] Akan tetapi, ada ancaman dengan model “Store Now, Decrypt Later (Simpan Sekarang, Dekripsi Nanti)”. Para peretas bisa mengumpulkan dan menyimpan komunikasi rahasia saat ini secara besar-besaran dalam bentuk terenkripsi, dengan strategi untuk mendekripsi semuanya seketika setelah komputer kuantum yang kuat berhasil dikembangkan dalam 10 hingga 20 tahun mendatang.

7. Transisi menuju Kriptografi Pasca-Kuantum (PQC)

Untuk bersiap menghadapi datangnya “Q-Day (Hari di mana komputer kuantum mematahkan kriptografi)”, ahli kriptografi dari seluruh dunia, dipimpin oleh Institut Nasional Standar dan Teknologi (NIST) di Amerika Serikat, sedang merumuskan Kriptografi Pasca-Kuantum (Post-Quantum Cryptography, PQC).

PQC didasarkan pada masalah matematis baru (seperti masalah kisi (lattice-based), polinomial multivariat, dan berbasis fungsi hash) yang secara matematis dianggap tidak dapat diselesaikan secara efisien bahkan jika menggunakan Algoritma Shor (ataupun Algoritma Grover). Algoritma seperti “CRYSTALS-Kyber” dan “CRYSTALS-Dilithium” telah dipilih sebagai standar, dan penerapannya secara bertahap mulai dilakukan pada iMessage milik Apple dan berbagai protokol komunikasi browser web.

Bagi teknisi yang mengelola infrastruktur TI, memasukkan “crypto-agility” (ketangkasan kriptografi: desain di mana metode kriptografi dapat dialihkan dengan cepat) dari enkripsi RSA atau kurva eliptik yang ada ke PQC ke dalam sistem mereka, akan menjadi misi utama yang sangat penting di masa depan.

8. Penutup

Dalam artikel ini, kami telah menjelaskan secara detail dan mendalam sekitar 10.000 karakter, mulai dari latar belakang teoretis matematis dari Algoritma Shor, mekanisme ekstraksi periode menggunakan Transformasi Fourier Kuantum, hingga kode simulasi konkret menggunakan Python dan Qiskit.

Fakta bahwa hukum fisika mikroskopis mekanika kuantum dapat meruntuhkan fondasi sains informasi makroskopis seperti teori kompleksitas komputasi dan teori kriptografi merupakan salah satu pergeseran paradigma paling menarik dalam sejarah sains. Kita patut untuk terus memperhatikan pertempuran yang sedang berlangsung antara teknologi komputasi kuantum yang terus berkembang dan teknologi kriptografi baru yang berusaha menangkalnya.

Silakan jalankan kode Python yang telah diperkenalkan pada lingkungan Anda masing-masing, dan rasakan sendiri “sihir komputasi” yang dihasilkan oleh superposisi keadaan kuantum dan interferensi.

Referensi

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Dokumentasi Qiskit: https://qiskit.org/documentation/