Distribusi kunci kuantum

Untuk modul Qiskit in Classrooms ini, siswa harus memiliki lingkungan Python yang berfungsi dengan paket-paket berikut yang sudah terpasang:

qiskit v2.1.0 atau lebih baru
qiskit-ibm-runtime v0.40.1 atau lebih baru
qiskit-aer v0.17.0 atau lebih baru
qiskit.visualization
numpy
pylatexenc

Untuk menyiapkan dan memasang paket-paket di atas, lihat panduan Pasang Qiskit. Untuk menjalankan job di komputer kuantum nyata, siswa perlu membuat akun IBM Quantum® dengan mengikuti langkah-langkah di panduan Siapkan akun IBM Cloud-mu.

Modul ini telah diuji dan menggunakan 5 detik waktu QPU. Ini hanya perkiraan. Penggunaan aktualmu mungkin berbeda.

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

# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

Tonton penjelasan modul oleh Dr. Katie McCormick di bawah ini, atau klik di sini untuk menontonnya di YouTube.

Pengenalan dan motivasi

Ada tak terhingga banyak cara untuk mengenkripsi dan mendekripsi informasi, dan ribuan cara telah dipelajari secara mendalam. Di sini, kita akan membatasi diri pada metode enkripsi yang sangat awal dan sangat sederhana, yang disebut "penggantian sederhana", agar bisa fokus pada bagian kuantum dari protokol ini. Bagian kuantum bisa diadaptasi ke banyak protokol lain dengan sedikit perubahan.

Penggantian sederhana

Enkripsi penggantian sederhana adalah enkripsi di mana satu huruf atau angka diganti dengan huruf atau angka lain, sehingga ada pemetaan 1:1 dari huruf dan angka dalam sebuah pesan ke huruf dan angka yang digunakan dalam urutan terenkripsi. Contoh populer dari ini adalah teka-teki kriptokuota atau kriptogram, di mana sebuah kutipan atau frasa dienkripsi menggunakan penggantian sederhana, dan pemain bertugas mendekripsinya. Teka-teki ini mudah dipecahkan jika cukup panjang. Perhatikan contoh berikut:

R WVXRWVW GSZG R'W YVGGVI NZPV GSRH KIVGGB OLMT. GSZG DZB, KVLKOV DROO SZEV ZM VZHRVI GRNV HLOERMT RG. R SLKV R NZWV RG HRNKOV VMLFTS.

Orang-orang yang memecahkan ini secara manual kebanyakan menggunakan trik yang melibatkan keakraban dengan struktur bahasa pesan asli. Misalnya, dalam bahasa Inggris, satu-satunya kata satu huruf seperti "R" yang terenkripsi adalah "a" dan "I". Huruf ganda yang terenkripsi, misalnya dalam "KIVGGB", hanya bisa mengambil nilai-nilai tertentu. Ada hal-hal yang lebih halus yang memberi petunjuk seperti kata yang paling umum yang cocok dengan pola "GSZG" adalah "that". Orang yang menggunakan kode untuk memecahkan ini punya banyak pilihan lebih, termasuk sekadar memindai kemungkinan-kemungkinan sampai kata bahasa Inggris ditemukan, dan memperbarui sambil mempertahankan kata itu. Satu metode yang sederhana namun kuat adalah menggunakan frekuensi huruf, terutama ketika pesannya cukup panjang untuk menjadi sampel representatif dari bahasa Inggris.

Pertanyaan check-in

Coba dekripsi ini kalau mau, meski tidak diperlukan untuk sisa modul. Klik tanda di bawah untuk melihat pesannya.

Jawaban:

I decided that I'd better make this pretty long. That way, people will have an easier time solving it. I hope I made it simple enough.

Contoh di atas dikaitkan dengan sebuah "kunci", yaitu pemetaan dari huruf terenkripsi ke huruf yang didekripsi. Dalam kasus ini, kuncinya adalah:

A (tidak digunakan, sebut saja Z)
B->Y
C (tidak digunakan, sebut saja X)
D->W
E->V
F->U
...

Dan seterusnya. Ini bukan kunci yang bagus, untuk dikatakan dengan sopan. Kunci di mana huruf terenkripsi dan yang didekripsi hanyalah versi yang digeser dari alfabet (seperti A->B dan B->C) disebut sandi "geseran Caesar".

Perlu dicatat bahwa ini sangat sulit jika pesannya pendek. Bahkan, jika sangat pendek, itu tidak dapat ditentukan. Perhatikan:

URYYP

Ada banyak kemungkinan dekripsi, menggunakan kunci berbeda: HELLO, PETTY, HAPPY, JIGGY, STOOL. Bisa kamu pikirkan yang lain?

Tapi kalau kamu mengirim banyak pesan seperti ini, pada akhirnya enkripsi akan dipecahkan. Jadi, kamu sebaiknya tidak menggunakan "kunci" yang sama terlalu sering. Bahkan, terbaik kalau kamu menggunakan substitusi tertentu hanya sekali. Bukan hanya dalam satu pesan, tapi hanya untuk satu karakter tunggal! Maksudnya, kamu akan punya skema enkripsi atau kunci untuk setiap karakter yang digunakan dalam pesan, secara berurutan. Jika kamu ingin mengirim pesan ke seorang teman menggunakan skema ini, kamu dan temanmu memerlukan selembar kertas (di zaman dahulu) tempat kunci yang selalu berubah ini ditulis. Kamu akan menggunakannya hanya sekali. Ini disebut "one-time pad".

One-time pad

Mari kita lihat cara kerjanya dengan sebuah contoh. Seseorang bisa melakukan ini sepenuhnya dengan huruf, tapi umum untuk mengonversi dari huruf ke angka, misalnya dengan menetapkan A=0, B=1, C=2…. Misalkan kita adalah teman yang terlibat dalam aktivitas rahasia dan kita telah berbagi sebuah pad. Idealnya, kita akan berbagi banyak pad, tapi untuk hari ini adalah:

EDGRPOJNCUWQZVMK…

Atau, dikonversi ke angka berdasarkan posisi dalam alfabet:

4,3,6,17,15, 14, 9, 13, 2, 20, 22, 16, 25, 21, 12, 10…

Misalkan aku ingin berbagi pesan ini denganmu:

"I love quantum!"

Atau, secara ekuivalen:

8, 11, 14, 21, 4, 16, 20, 0, 13, 19, 20, 12

Kita tidak mau mengirimkan kode di atas; itu adalah substitusi sederhana, yang sama sekali tidak aman. Kita ingin menggabungkannya dengan kunci kita dengan cara tertentu. Cara umum adalah penjumlahan modulo 26. Kita menjumlahkan nilai pesan dengan nilai kunci, mod 26, sampai kita mencapai akhir pesan. Jadi, kita akan mengirimkan

8+4 (mod 26) = 12, 11+3 (mod 26) = 14, 14+6 (mod 26) = 20, 21+17 (mod 26) = 12…

= 12, 14, 20, 12, 19, 4, 3, 13, 15, 13, 16, 2

Perhatikan bahwa jika seseorang menyadap ini dan TIDAK memiliki kuncinya, mendekripsinya sama sekali tidak ada harapan! Bahkan dua "u" dalam "quantum" tidak dikodekan dengan angka yang sama! Yang pertama adalah 3, dan yang kedua adalah 16… dalam kata yang sama!

Jadi, aku mengirimkan ini kepadamu, dan kamu memiliki kunci yang sama denganku. Kamu membatalkan penjumlahan modulo 26 yang kamu tahu telah aku lakukan:

12, 14, 20, 12, 19, 4, 3, 13, 15, 13, 16, 2

=(4+x1) (mod 26), (3+x2) (mod 26), (6+x3) (mod 26), (17+x4) (mod 26),…

Sehingga pesan x1, x2, x3, x4… harus bernilai

8, 11, 14, 21…

Akhirnya, mengonversi ini ke teks, kita mendapatkan

"I love quantum".

Ini adalah one-time pad.

Perlu dicatat bahwa jika kunci lebih pendek dari pesan, kita mulai mengulang pengkodean kita. Itu masih akan menjadi masalah dekripsi yang sulit untuk dipecahkan, tapi tidak mustahil jika diulang cukup sering. Jadi, kamu butuh kunci (atau "pad") yang panjang.

catatan

Dalam banyak konteks, siswa sudah familiar dengan enkripsi ini, sehingga aktivitas ini bisa dilewati. Tapi ini adalah penyegaran yang relatif cepat dan sederhana.

Langkah 1: Cari pasangan, dan bagikan urutan 4 huruf untuk digunakan sebagai kunci. Urutan 4 huruf apa saja yang sesuai untuk kelas bisa digunakan.
Langkah 2: Pilih kata rahasia 4 huruf yang ingin kamu kirim ke pasanganmu (kedua pasangan melakukan ini sehingga kalian saling mengirim kata rahasia yang berbeda)
Langkah 3: Konversi kunci/pad 4 huruf dan setiap kata rahasia 4 huruf ke angka menggunakan A = 1, B = 2, dan seterusnya.
Langkah 4: Gabungkan kata 4 hurufmu dengan one-time pad menggunakan penjumlahan modulo 26.
Langkah 5: Berikan ke pasanganmu urutan angka yang mengkodekan kata rahasiamu, dan pasanganmu akan memberikan miliknya kepadamu.
Langkah 6: Dekripsi kata satu sama lain menggunakan pengurangan modulo 26.
Langkah 7: Verifikasi. Berhasil?

Tindak lanjut

Tukarkan kata terenkripsi dengan kelompok berbeda yang tidak memiliki akses ke one-time pad-mu. Bisakah kamu mendekripsinya? Jelaskan kenapa atau kenapa tidak?

Semoga aktivitas di atas memperjelas bahwa one-time pad adalah bentuk enkripsi yang tidak bisa dipecahkan, dengan beberapa asumsi, seperti:

Kunci memiliki panjang yang sama dengan pesan yang dikirim, atau lebih panjang
Kunci benar-benar acak
Kunci digunakan hanya sekali lalu dibuang

Jadi, ini luar biasa. Kita punya enkripsi yang tidak bisa dipecahkan... kecuali seseorang mendapatkan kunci kita. Jika seseorang mendapatkan kunci kita, semua rahasia terekspos. Perbedaan antara enkripsi yang tidak bisa dipecahkan dan semua rahasia kita terekspos membuat berbagi kunci yang aman menjadi sangat penting. Tujuan distribusi kunci kuantum adalah memanfaatkan batasan yang telah diberlakukan alam pada informasi kuantum untuk mengamankan kunci/one-time pad yang dibagikan.

Menggunakan keadaan kuantum sebagai kunci

Mari kita asumsikan kita bekerja dengan qubit (menekankan bahwa qubit memiliki dua eigenstate). Seseorang bisa menggunakan sistem kuantum dengan jumlah keadaan kuantum yang lebih tinggi, tapi komputer kuantum terdepan di IBM® menggunakan qubit. Tidak masalah untuk mengkodekan A, B, C, kita ke dalam urutan 0 dan 1. Jadi, cukup bagi kita untuk berbagi kunci dari 0 dan 1 dan melakukan penjumlahan modulo 2 pada setiap bit yang menyimpan sebuah huruf.

Cek pemahamanmu

Baca pertanyaan di bawah, pikirkan jawabanmu, lalu klik segitiga untuk mengungkap solusinya.

Jika kita benar-benar hanya peduli dengan huruf-huruf Inggris, berapa banyak bit yang kita butuhkan?

Jawaban:

2^4=16\\ 2^5 = 32 \rightarrow 5 \text{ bits}

Teman-teman kita, Alice dan Bob ingin berbagi kunci kuantum sedemikian rupa sehingga tidak ada orang lain yang bisa menyadapnya (setidaknya tidak tanpa mereka ketahui). Mereka perlu punya cara untuk mengirimkan keadaan kuantum satu sama lain. Melakukan ini dengan fidelitas tinggi dan tanpa noise/kesalahan TIDAK mudah. Tapi ada dua pendekatan yang seharusnya bisa kita pahami saat ini:

Kabel serat optik memungkinkan kamu mengirimkan cahaya… yang sangat mekanika kuantum. Foton tunggal bisa dideteksi dengan fidelitas tinggi di seluruh ribuan kilometer kabel serat optik. Ini bukan saluran kuantum yang sempurna dan bebas kesalahan, tapi bisa sangat baik.
Kita bisa menggunakan teleportasi kuantum, seperti yang dijelaskan dalam modul sebelumnya. Artinya, Alice dan Bob bisa berbagi qubit yang terjerat dan sebuah keadaan bisa dikirimkan dari Alice ke Bob menggunakan protokol teleportasi.

Untuk modul ini, kita tidak ingin mengharuskanmu memiliki setup optik fidelitas tinggi untuk berbagi foton, jadi kita akan menggunakan metode kedua untuk berbagi keadaan kuantum. Tapi ini bukan berarti metode ini paling realistis untuk berbagi kunci kuantum jarak jauh.

Kita sekarang akan mengeksplorasi protokol yang pertama kali dikemukakan oleh Charles Bennett dan Gilles Brassard pada tahun 1984 untuk berbagi keadaan yang diukur dalam basis berbeda dari Alice ke Bob. Kita akan menggunakan skema pengukuran yang cerdas untuk membangun kunci yang akan digunakan dalam enkripsi selanjutnya. Dengan kata lain, kita mendistribusikan kunci kuantum antara dua pihak yang ingin berkomunikasi, yang disebut "distribusi kunci kuantum" (QKD).

QKD langkah 1: Bit acak dan basis acak Alice

Alice akan memulai dengan menghasilkan urutan acak dari 0 dan 1. Kemudian dia akan secara acak memilih basis untuk menyiapkan keadaan kuantum, berdasarkan setiap bit acak, menggunakan tabel di bawah (tabel yang juga dimiliki Bob):

Basis	bit = 0	bit = 1
Z	$\vert 0\rangle$	$\vert 1\rangle$
X	$\vert +\rangle$	$\vert -\rangle$

Misalnya, misalkan Alice secara acak menghasilkan 0, dan secara acak memilih basis X. Maka dia akan menyiapkan keadaan kuantum $|\psi\rangle = |+\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ . Seseorang tentu bisa memanfaatkan keacakan kuantum untuk menghasilkan sekumpulan acak 0 dan 1, dan pilihan basis acak. Untuk saat ini, mari kita asumsikan saja bahwa sekumpulan acak telah dihasilkan, sebagai berikut:

Bit Alice	0	1	0	0	1	1	0	1	0	...
Basis Alice	X	X	Z	Z	Z	X	Z	Z	X	...
Keadaan Alice	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert +\rangle$	...

Sekumpulan bit acak, basis, dan keadaan yang dihasilkan ini akan berlanjut dalam urutan panjang, untuk memberikan kunci dengan panjang yang cukup.

QKD langkah 2: Basis acak Bob

Bob juga membuat pilihan basis secara acak. Namun, sementara Alice menggunakan pilihan basis untuk menyiapkan keadaannya, Bob sebenarnya akan melakukan pengukuran dalam basis-basis ini. Jika Bob melakukan pengukuran dalam basis yang sama dengan yang digunakan Alice dalam persiapan, maka kita bisa memprediksi hasil pengukuran Bob. Ketika Bob kebetulan memilih basis yang berbeda dari basis yang digunakan Alice dalam persiapan, kita tidak bisa mengetahui hasil pengukuran Bob.

Bit Alice	0	1	0	0	1	1	0	1	0	...
Basis Alice	X	X	Z	Z	Z	X	Z	Z	X	...
Keadaan Alice	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert +\rangle$	...
Basis Bob	X	Z	X	Z	X	X	Z	X	X	...
Keadaan Bob (a priori)	$\vert +\rangle$	?	?	$\vert 0\rangle$	?	$\vert -\rangle$	$\vert 0\rangle$	?	$\vert +\rangle$	...
Keadaan Bob (diukur)	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Dalam tabel di bawah, perhatikan kolom pertama. Alice telah menyiapkan keadaan $\vert +\rangle,$ yang merupakan eigenstate dari X. Karena Bob juga secara acak memilih untuk mengukur dalam basis X, hanya ada satu kemungkinan hasil untuk keadaan yang diukur Bob: $\vert +\rangle.$ Namun di kolom kedua, mereka memilih basis yang berbeda. Keadaan yang dikirim Alice adalah $\vert -\rangle = \frac{1}{\sqrt{2}}(\vert 0\rangle-\vert 1 \rangle).$ Ini memiliki peluang 50% untuk diukur Bob dalam keadaan $\vert 0\rangle$ , dan peluang 50% untuk diukur dalam $\vert 1\rangle.$ Jadi baris yang menunjukkan apa yang kita ketahui, secara a priori, tentang pengukuran Bob tidak bisa diisi untuk kolom 2. Tapi Bob akan melakukan pengukuran dan mendapatkan eigenstate dari (di kolom itu) Z. Di baris bawah, kita mengisi apa yang ternyata dihasilkan oleh pengukuran-pengukuran tersebut.

QKD langkah 3: Diskusi publik tentang basis

Alice dan Bob sekarang bisa saling berbagi basis mana yang mereka pilih dalam setiap kasus. Untuk semua kolom di mana mereka kebetulan memilih basis yang sama, mereka masing-masing tahu dengan pasti keadaan apa yang dimiliki pihak lain. Bob bisa mengonversi keadaan dan basis ke 0 atau 1 sesuai dengan konvensi yang dibagikan oleh kedua belah pihak. Kita bisa menulis ulang tabel di atas untuk hanya menampilkan contoh-contoh di mana basis Alice dan Bob cocok:

Bit Alice	0	0	1	0	0	...
Basis Alice	X	Z	X	Z	X	...
Keadaan Alice	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Basis Bob	X	Z	X	Z	X	X
Keadaan Bob (a priori)	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Keadaan Bob (diukur)	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Bit Bob	0	0	1	0	0	...

Alice telah berhasil mengirimkan string bit 00100... ke Bob. Jika para teman telah sepakat sebelumnya untuk menggunakan string 5-bit sebagai angka dalam one-time pad mereka, lima bit pertama ini akan memberi mereka angka $4 = 0\times2^4+0\times2^3+1\times2^2+0\times2^1+0\times2^0.$

QKD langkah 4: Verifikasi dan kirim rahasia

Sebelum Alice dan Bob melangkah lebih jauh, mereka harus memilih sebagian dari bit klasik mereka untuk dibandingkan. Karena mereka hanya menyimpan pengukuran qubit yang disiapkan dan diukur menggunakan basis yang sama, semua nilai yang diukur seharusnya cocok. Jika ada persentase kecil yang tidak cocok, ini bisa dikaitkan dengan noise kuantum atau kesalahan. Tapi jika banyak yang tidak cocok, ada yang salah!

Di sini kita tidak akan membahas berapa fraksi kunci yang harus digunakan untuk verifikasi. Untuk saat ini, kita akan berasumsi bahwa pemeriksaan ini berjalan dengan baik; kita akan kembali ke ini di bagian bawah tentang penyadapan.

Para teman kemudian akan saling mengirimkan pesan terenkripsi melalui saluran klasik. Mereka kemudian akan menggunakan angka-angka dalam one-time pad mereka untuk mengenkripsi/mendekripsi pesan rahasia, tanpa pernah mengirimkan one-time pad dari satu lokasi ke lokasi lain. Untuk bagian selanjutnya tentang penyadapan, harap ingat bahwa semua berbagi kunci ini terjadi sebelum pengungkapan rahasia terenkripsi melalui saluran klasik.

Alice dan Bob mengomunikasikan pilihan basis mereka melalui saluran klasik, jadi bukankah itu bisa disadap? Ya! Tapi mengetahui basis yang mereka gunakan untuk pengukuran tidak memberitahumu bit apa yang mereka kirim atau diperoleh. Itu hanya mungkin jika kamu juga mengetahui bit awal Alice. Tapi kalau begitu kamu sudah ada di komputer Alice, tempat rahasia-rahasia disimpan, dan komunikasi rahasia tentang rahasia-rahasia itu menjadi tidak berarti. Jadi penyadapan komunikasi klasik tidak merusak enkripsi. Tapi bagaimana dengan menyadap informasi di saluran kuantum?

Ketahanan QKD terhadap penyadapan

Alice dan Bob memiliki teman Eve, yang terkenal karena suka menyadap. Eve ingin menyadap kunci kuantum Alice dan Bob, agar bisa menggunakannya untuk mendekripsi pesan yang dikirim antara keduanya. Ini pasti terjadi antara persiapan keadaan oleh Alice dan pengukuran keadaan oleh Bob, karena pengukuran meruntuhkan keadaan kuantum. Khususnya, ini berarti penyadapan harus terjadi sebelum ada berbagi atau perbandingan basis apapun.

Eve harus menebak basis mana yang digunakan dalam mengkodekan setiap bit. Sekali lagi, jika dia tidak bisa mengakses komputer Alice, dia tidak punya dasar untuk tebakan ini, dan itu akan acak. Mari kita asumsikan awal Alice sama seperti sebelumnya, dan mari kita asumsikan lebih lanjut bahwa pilihan basis pengukuran acak Bob sama seperti sebelumnya. Mari kita isi apa yang diperoleh Eve jika dia melakukan pengukuran saluran kuantum. Seperti sebelumnya, jika Eve kebetulan memilih basis yang sama dengan Alice, kita tahu apa yang akan dia peroleh. Jika tidak, dia bisa mendapatkan salah satu dari dua hasil, masing-masing dengan peluang 50%.

Bit Alice	0	1	0	0	1	1	0	1	0	...
Basis Alice	X	X	Z	Z	Z	X	Z	Z	X	...
Keadaan Alice	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert +\rangle$	...
Basis tebakan Eve	Z	X	X	Z	X	Z	Z	X	X	...
Keadaan Eve (a priori)	?	$\vert -\rangle$	?	$\vert 0\rangle$	?	?	$\vert 0\rangle$	?	$\vert +\rangle$	...
Keadaan Eve (diukur)	$\vert 1\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Basis Bob	X	Z	X	Z	X	X	Z	X	X	...

Sekarang karena Eve tidak tahu apakah dia cocok dengan basis Alice atau tidak, dia tidak tahu apa yang harus diteruskan ke Bob agar cocok dengan keadaan asli Alice. Ketika Eve mengukur, misalnya, $|0\rangle,$ yang dia ketahui dengan pasti hanyalah bahwa Alice tidak menyiapkan keadaan $|1\rangle$ untuk qubit tersebut. Tapi Alice bisa saja menyiapkan $|0\rangle,$ $|+\rangle,$ atau $|-\rangle.$ Semuanya bisa konsisten dengan pengukuran Eve. Jadi Eve harus membuat pilihan. Dia mungkin meneruskan tepat keadaan yang dia ukur, atau dia mungkin mencoba menebak kasus-kasus di mana pengukurannya bukan eigenstate yang dikirim Alice. Kita akan menyertakan campuran dalam tabel kita:

Bit Alice	0	1	0	0	1	1	0	1	0	...
Basis Alice	X	X	Z	Z	Z	X	Z	Z	X	...
Keadaan Alice	$\vert +\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert +\rangle$	...
Basis tebakan Eve	Z	X	X	Z	X	Z	Z	X	X	...
Keadaan Eve (a priori)	?	$\vert -\rangle$	?	$\vert 0\rangle$	?	?	$\vert 0\rangle$	?	$\vert +\rangle$	...
Keadaan Eve (diukur)	$\vert 1\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Keadaan Eve (diteruskan)	$\vert 1\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	...
Basis Bob	X	Z	X	Z	X	X	Z	X	X	...
Keadaan Bob (a priori)	?	$\vert 0\rangle$	?	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Keadaan Bob (diukur)	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	...
Bit Bob	1	0	0	0	1	0	0	1	0	...

Pada titik ini, wajar untuk bertanya, "Kenapa Eve tidak sekadar membuat salinan keadaan kuantum Alice, menyimpan satu untuk diukur, dan meneruskan yang lain ke Bob?" Jawabannya adalah teorema "no-cloning". Secara informal, ini menyatakan bahwa tidak ada operasi uniter (mekanika kuantum) yang bisa membuat salinan kedua dari keadaan kuantum arbitrer, sembari mempertahankan salinan pertama. Buktinya relatif sederhana, dan diserahkan sebagai latihan terbimbing. Tapi untuk sekarang, pahami bahwa Eve membuat salinan keadaan kuantum dilarang oleh hukum dasar alam, dan ini adalah kekuatan prinsip QKD. Seperti sebelumnya, Alice dan Bob akan saling menelepon dan membandingkan basis. Mereka akan mereduksi tabel ini ke kasus-kasus di mana dua teman memilih basis yang sama:

Bit Alice	0	0	1	0	0	...
Basis Alice	X	Z	X	Z	X	...
Keadaan Alice	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Basis tebakan Eve	Z	Z	Z	Z	X	...
Keadaan Eve (a priori)	?	$\vert 0\rangle$	?	$\vert 0\rangle$	$\vert +\rangle$	...
Keadaan Eve (diukur)	$\vert 1\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Keadaan Eve (diteruskan)	$\vert 1\rangle$	$\vert 0\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	...
Basis Bob	X	Z	X	Z	X	...
Keadaan Bob (a priori)	?	$\vert 0\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Keadaan Bob (diukur)	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Bit Bob	1	0	0	0	0	...

Alice dan Bob sekali lagi telah mengomunikasikan string bit... tapi string-nya tidak cocok. Bit paling kiri dan bit tengah bertukar. Melihat tabel sebelumnya, kamu bisa melacak ketidaksesuaian ini ke gangguan dari Eve. Yang krusial, perhatikan bahwa kita bisa melakukan statistik pada kecocokan antara bitstring kita sekarang, saat menyiapkan kunci, jauh sebelum berbagi rahasia terenkripsi kita. Alice dan Bob bebas menggunakan sebanyak mungkin bit one-time pad mereka untuk memeriksa keamanan saluran mereka. Jika satu bit, atau persentase sangat kecil dari bit tidak cocok, ini mungkin dikaitkan dengan noise atau kesalahan. Tapi sebagian besar yang tidak cocok mengindikasikan penyadapan. Makna "sebagian besar" di sini sedikit bergantung pada noise dalam setup yang digunakan; apa artinya untuk komputer kuantum IBM® dibahas di bawah ketika kita mengimplementasikan protokol ini. Jika kelebihan kesalahan terdeteksi, Alice dan Bob tidak berbagi rahasia, dan mereka bisa mulai mencari penyadap.

Peringatan

Membuktikan keamanan sangat sulit. Bahkan protokol yang digambarkan secara longgar di sini diusulkan pada tahun 1984, dan baru terbukti aman 16 tahun kemudian Shor & Preskill, 2000. Ada banyak kehalusan yang berada di luar cakupan pengenalan ini. Tapi kita akan secara singkat mendaftar beberapa untuk menunjukkan bahwa topik ini lebih kompleks dari yang diilustrasikan di sini.

Saluran aman: Ketika Alice mengirimkan qubit-nya melalui beberapa setup kuantum (saluran), dan khususnya ketika dia menerima respons klasik kembali dari seseorang, kita telah berasumsi bahwa seseorang itu memang Bob. Jika Eve menyusup ke setup ini sedemikian rupa sehingga semua komunikasi Alice sebenarnya terjadi dengan Eve, dan semua komunikasi Bob sebenarnya dilakukan dengan Eve, maka Eve secara efektif telah mendapatkan kunci, dan bisa mempelajari rahasia-rahasia. Seseorang harus terlebih dahulu memastikan "saluran aman", sebuah proses dengan seperangkat protokol berbeda yang belum kita bahas di sini.
Asumsi tentang Eve: Untuk benar-benar membuktikan keamanan, kita tidak bisa membuat asumsi tentang perilaku Eve; dia selalu bisa mengecewakan ekspektasi kita. Di sini, untuk memberikan contoh konkret, kita membuat asumsi. Misalnya, kita mungkin berasumsi bahwa keadaan yang diteruskan Eve ke Bob selalu persis keadaan yang dia peroleh saat pengukuran. Atau kita mungkin berasumsi bahwa dia secara acak memilih keadaan yang secara eksperimental konsisten dengan pengukurannya. Yang lebih mendasar, bahasa di sini mengasumsikan bahwa Eve sebenarnya melakukan pengukuran, berbeda dengan menyimpan keadaan pada sistem kuantum lain dan mengirimkan qubit acak ke Bob. Asumsi-asumsi ini bagus untuk memahami protokol, tapi berarti kita tidak membuktikan apa pun secara penuh.
Amplifikasi privasi: Alice dan Bob tidak diharuskan menggunakan kunci kuantum tepat seperti yang ditransmisikan. Mereka bisa, misalnya, menerapkan fungsi hash ke kunci bersama. Ini akan memanfaatkan fakta bahwa penyadap memiliki pengetahuan yang tidak lengkap tentang kunci untuk menghasilkan kunci bersama yang lebih pendek, tapi aman.

Eksperimen 1: QKD tanpa penyadap

Mari kita implementasikan protokol di atas tanpa kehadiran penyadap. Kita akan melakukan ini terlebih dahulu menggunakan simulator, hanya untuk memahami alur kerjanya.

Pertama, catatan tentang simulator kuantum: Sebagian besar masalah kuantum yang melibatkan lebih dari ~30 qubit tidak bisa disimulasikan oleh kebanyakan komputer. Tidak ada komputer klasik, superkomputer, atau GPU yang bisa mensimulasikan rentang penuh perilaku komputer kuantum 127-qubit. Biasanya, motivasi untuk menggunakan komputer kuantum nyata adalah bahwa banyak qubit yang terjerat tidak bisa disimulasikan. Dalam kasus ini, tidak ada jerat qubit, kecuali jika kita menggunakan skema teleportasi untuk memindahkan informasi. Dalam kasus ini, motivasi untuk menggunakan komputer kuantum nyata berbeda: yaitu teorema no-cloning. Komputer klasik yang mensimulasikan qubit bisa mengirimkan informasi tentang keadaan kuantum dari Alice ke Bob, tapi jika informasi klasik ini disadap, itu bisa dengan mudah digandakan, dan Eve bisa menyimpan salinan sempurna, sembari mengirimkan yang lain ke Bob. Ini tidak mungkin dengan keadaan kuantum nyata.

IBM Quantum merekomendasikan penanganan masalah komputasi kuantum menggunakan kerangka kerja yang disebut "pola Qiskit". Ini terdiri dari langkah-langkah berikut.

Langkah 1: Petakan masalahmu ke Circuit kuantum
Langkah 2: Optimalkan Circuit-mu untuk dijalankan pada hardware kuantum nyata
Langkah 3: Jalankan job-mu di komputer kuantum IBM menggunakan primitif Runtime
Langkah 4: Proses hasil pasca-eksekusi

Pola Qiskit langkah 1: Petakan masalahmu ke Circuit kuantum

Dalam kasus ini, pemetaan masalah kita ke Circuit kuantum tereduksi menjadi sekadar menyiapkan keadaan Alice, lalu menyertakan pengukuran Bob. Kita mulai dengan pemilihan bit acak dan basis acak.

# Qiskit patterns step 1: Map your problem to quantum circuit
# Import some generic packages

import numpy as np
from qiskit import QuantumCircuit

# Set up a random number generator and a quantum circuit. We choose to start with 20 bits, though any number <30 should be fine.

rng = np.random.default_rng()
bit_num = 20
qc = QuantumCircuit(bit_num, bit_num)

# QKD step 1: Random bits and bases for Alice
# generate Alice's random bits

abits = np.round(rng.random(bit_num))

# generate Alice's random measurement bases. Here we will associate a "0" with the Z basis, and a "1" with the X basis.

abase = np.round(rng.random(bit_num))

# Alice's state preparation. Check that this creates states according to table 1

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# QKD step 2: Random bases for Bob
# generate Bob's random measurement bases.

bbase = np.round(rng.random(bit_num))

# Note that if Bob measures in Z no gates are necessary, since IBM Quantum computers measure in Z by default.
# If Bob measures in the X basis, we implement a hadamard gate qc.h to facilitate the measurement.

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(m, m)

Mari kita visualisasikan bit, basis, dan Circuit. Perhatikan bahwa terkadang basis cocok, dan terkadang tidak.

print("Alice's bits are ", abits)
print("Alice's bases are ", abase)
print("Bob's bases are ", bbase)
qc.draw("mpl")

Alice's bits are  [1. 1. 0. 1. 0. 1. 1. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 0. 0.]
Alice's bases are  [0. 0. 0. 1. 1. 0. 0. 0. 0. 1. 1. 1. 1. 1. 0. 1. 1. 0. 1. 0.]
Bob's bases are  [0. 1. 1. 0. 1. 0. 1. 1. 0. 0. 1. 1. 0. 0. 1. 0. 1. 1. 0. 0.]

Output of the previous code cell

Pola Qiskit langkah 2: Optimalkan masalah untuk eksekusi kuantum

Langkah ini mengambil operasi yang ingin kita lakukan dan mengekspresikannya dalam hal fungsionalitas komputer kuantum tertentu. Ini juga memetakan masalah kita ke tata letak komputer kuantum.

Kita akan mulai dengan memuat beberapa paket yang diperlukan untuk berkomunikasi dengan komputer kuantum IBM. Kita juga harus memilih Backend untuk dijalankan. Kita bisa memilih Backend yang paling tidak sibuk, atau memilih Backend tertentu yang propertinya kita ketahui. Meskipun kita sebentar lagi akan menggunakan simulator, penting untuk menggunakan model noise yang masuk akal dalam simulasi, dan lebih baik menjaga alur kerja sedekat mungkin dengan yang akan kita gunakan nanti untuk komputer kuantum nyata.

Ada kode di bawah ini untuk menyimpan kredensialmu saat pertama kali digunakan. Pastikan untuk menghapus informasi ini dari notebook setelah menyimpannya ke lingkunganmu, agar kredensialmu tidak secara tidak sengaja dibagikan ketika kamu berbagi notebook. Lihat Siapkan akun IBM Cloud-mu dan Inisialisasi layanan di lingkungan yang tidak tepercaya untuk panduan lebih lanjut.

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load the Qiskit Runtime service

# Syntax for first saving your token.  Delete these lines after saving your credentials.
# QiskitRuntimeService.save_account(channel='ibm_quantum_platform', instance = '<YOUR_IBM_INSTANCE_CRN>', token='<YOUR-API_KEY>', overwrite=True, set_as_default=True)
# service = QiskitRuntimeService(channel='ibm_quantum_platform')

# Load saved credentials
service = QiskitRuntimeService()

# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_brisbane".
# backend = service.least_busy(operational=True, simulator=False, min_num_qubits = 127)
backend = service.backend("ibm_brisbane")
print(backend.name)

ibm_brisbane

Di bawah ini kita memilih simulator dan model noise.

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

# Load the Aer simulator and generate a noise model based on the currently-selected backend.
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel

# Load the qiskit runtime sampler
from qiskit_ibm_runtime import SamplerV2 as Sampler

noise_model = NoiseModel.from_backend(backend)

# Define a simulator using Aer, and use it in Sampler.
backend_sim = AerSimulator(noise_model=noise_model)
sampler_sim = BackendSamplerV2(backend=backend_sim)

# Qiskit patterns step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

Pola Qiskit langkah 3: Eksekusi

Gunakan Sampler untuk menjalankan job-mu, dengan Circuit sebagai argumen.

# This required 5 s to run on a Heron r2 processor on 10-28-24
sampler = Sampler(mode=backend)
job = sampler.run([qc_isa], shots=1)
# job = sampler_sim.run([qc], shots = 1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

Pola Qiskit langkah 4: Pasca-pemrosesan

Di sini kita menginterpretasikan hasil kita dan mengekstrak informasi yang berguna. Kita mungkin mencoba memvisualisasikan output dari Sampler kita, tapi kita telah menggunakan Sampler dengan cara yang tidak konvensional. Alih-alih membuat banyak pengukuran dari Circuit kita dan mengembangkan statistik tentang keadaan-keadaan, kita hanya melakukan satu pengukuran (pengukuran Bob). Setiap qubit dengan keadaan yang disiapkan dan diukur dalam basis yang sama seharusnya memiliki hasil yang deterministik, sehingga hanya satu pengukuran yang diperlukan. Qubit-qubit yang keadaannya disiapkan dan diukur dalam basis yang berbeda (yang akan memiliki hasil probabilistik dan memerlukan banyak pengukuran untuk diinterpretasikan) tidak akan digunakan untuk membangun one-time pad/kunci kita. Mari kita ekstrak daftar hasil pengukuran dari bitstring ini. Perhatikan untuk membalik urutan jika membandingkan dengan array bit Alice yang kita gunakan untuk menghasilkan Circuit.

# Get an array of bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))

# Reverse the order to match our input. See "little endian" notation.

bbits = bmeas_ints[::-1]

print(bbits)

[1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0]

Mari kita bandingkan basis pengukuran yang dipilih secara acak oleh Alice dan Bob. Ini adalah langkah 3 dalam protokol QKD kita (diskusi publik tentang basis). Setiap kali mereka memilih basis yang sama untuk suatu qubit, kita tambahkan bit yang terkait dengan qubit itu ke daftar bit untuk menghasilkan angka dalam one-time pad. Ketika basis tidak cocok, hasilnya dibuang. Mari kita juga periksa apakah dua daftar bit cocok, atau apakah ada kerugian akibat noise atau faktor lainnya.

# QKD step 3: Public discussion of bases

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    # Check whether bases matched.
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        # If bits match when bases matched, increase count of matching bits
        if int(abits[n]) == bbits[n]:
            match_count += 1

print(agoodbits)
print(bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

[1, 0, 1, 0, 0, 0, 1, 0]
[1, 0, 1, 0, 0, 0, 1, 0]
fidelity =  1.0
loss =  0.0

Alice dan Bob masing-masing memiliki daftar bit, dan keduanya cocok dengan fidelitas 100%. Mereka bisa menggunakan ini untuk menghasilkan angka-angka dalam one-time pad. Mereka kemudian bisa menggunakannya dalam QKD langkah 4: mengirim dan mendekripsi sebuah rahasia. Array bit saat ini terlalu pendek untuk mendekripsi banyak hal. Kita akan kembali ke ini setelah menyertakan penyadapan.

Cek pemahamanmu

Baca pertanyaan di bawah, pikirkan jawabanmu, lalu klik segitiga untuk mengungkap solusinya.

Asumsikan kamu butuh digit yang cukup besar untuk memfasilitasi penggeseran huruf-huruf dalam alfabet Inggris sepanjang alfabet tersebut, atau lebih, meskipun tentu ada skema pengkodean lain. (a) Berapa huruf panjang sebuah pesan yang bisa didekripsi menggunakan bit dalam kunci di atas? (b) Apakah jawabanmu harus sama dengan teman sekelas? Kenapa atau kenapa tidak?

Jawaban:

(a) Jawabannya bergantung pada berapa banyak basis yang dipilih secara acak yang cocok antara Alice dan Bob. Karena ada peluang kira-kira 50-50 bahwa basis cocok untuk qubit mana pun, kita harapkan hampir 10 dari bit kita akan berguna. 9 atau 11 sangat umum. Bahkan 4 atau 15 tidak di luar kemungkinan. 5 bit diperlukan untuk menggeser lebih dari atau sama dengan panjang alfabet Inggris, artinya kamu bisa menerapkan geseran ke satu huruf untuk setiap 5 bit yang kamu miliki. Jika kamu memiliki setidaknya 5 bit yang dibagikan oleh Alice dan Bob, kamu bisa mengkodekan satu huruf. Jika kamu memiliki setidaknya 10, kamu bisa mengkodekan 2 huruf, dan seterusnya. (b) Tidak harus cocok, karena alasan yang diuraikan dalam (a).

Eksperimen 2: QKD dengan penyadap

Kita akan mengimplementasikan protokol yang sama persis seperti sebelumnya. Kali ini, kita akan menyisipkan satu set pengukuran tambahan oleh Eve, di antara Alice dan Bob.

from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister

# Qiskit patterns step 1: Mapping your problem to a quantum circuit
# QKD step 1: Random bits and bases for Alice

bit_num = 20
qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Alice's random bits and bases, as before

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation, as before

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# Eavesdropping happens here!
# Generate Eve's random measurement bases

ebase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if ebase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

# Qiskit patterns step 3: Execute
job = sampler_sim.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

Langkah 4 Qiskit patterns (pasca-pemrosesan) sederhana dalam kasus ini. Tidak perlu memvisualisasikan distribusi pengukuran, karena kita hanya melakukan satu pengukuran. Eve memiliki bit-bit berikut:

keys = counts.keys()
key = list(keys)[0]
emeas = list(key)
emeas_ints = []
for n in range(bit_num):
    emeas_ints.append(int(emeas[n]))
ebits = emeas_ints[::-1]

print(ebits)

[0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1]

Sekarang Eve harus merekonstruksi state untuk dikirimkan ke Bob. Seperti yang dijelaskan di bagian pendahuluan, Eve tidak punya cara untuk mengetahui apakah dia menebak basis pengkodean dengan benar, sehingga dia tidak dapat menyiapkan state yang sama persis dengan yang dikirim. Eve bisa berasumsi setiap pilihan basis sudah benar dan mengkodekan persis apa yang dia ukur, atau bisa berasumsi dia memilih basis yang salah dan memilih salah satu eigenstate dari basis yang berlawanan. Di sini, kita asumsikan yang pertama, demi kesederhanaan. Kita mencapai ini dengan membuat seluruh Circuit kuantum baru, mengulang langkah-langkah Qiskit patterns seperti sebelumnya.

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# Qiskit patterns step 1: Mapping your problem onto a quantum circuit
# QKD step 1: Eve uses her measurements to prepare best guess states to send on to Bob

qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Eve's state preparation

for n in range(bit_num):
    if ebits[n] == 0:
        if ebase[n] == 1:
            qc.h(n)
    if ebits[n] == 1:
        if ebase[n] == 0:
            qc.x(n)
        if ebase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

# Qiskit patterns step 3: Execute

job = sampler_sim.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

print(bbits)

[0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1]

Mari kita bandingkan bit-bit Alice dan Bob:

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1
print(agoodbits)
print(bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

[1, 1, 0, 0, 0, 1, 1]
[1, 1, 0, 0, 0, 0, 1]
fidelity =  0.8571428571428571
loss =  0.1428571428571429

Sebelumnya, ada kecocokan sempurna antara bit-bit di kunci Alice dan Bob. Sekarang, akibat interferensi Eve, kita melihat bit-bit Alice dan Bob berbeda dalam 14% kasus yang seharusnya cocok karena Alice dan Bob memilih basis yang sama. Ini seharusnya mudah dideteksi oleh Alice dan Bob. Namun, mengandalkan persentase kesalahan seperti ini memang berarti ada batas seberapa banyak noise yang bisa kita toleransi di kanal kuantum.

Eksperimen 3: Bandingkan QKD dengan dan tanpa penyadapan di komputer kuantum nyata

Mari kita jalankan ini di komputer kuantum nyata. Dengan begitu kita bisa memanfaatkan teorema no-cloning. Namun di sisi lain, komputer kuantum nyata memiliki noise, dan tingkat kesalahan yang lebih tinggi dibanding komputer klasik. Jadi mari kita bandingkan kehilangan fidelitas pada bit kunci kita dengan dan tanpa penyadapan, untuk memastikan perbedaannya bisa terdeteksi saat menggunakan komputer kuantum nyata. Kita mulai tanpa penyadapan:

from qiskit_ibm_runtime import SamplerV2 as Sampler

# This calculation was run on an Eagle r3 processor on 11-7-24 and required 3 sec to run, with 127 qubits.
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

bit_num = 127
qc = QuantumCircuit(bit_num, bit_num)

# QKD step 1: Generate Alice's random bits and bases

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(m, m)

# Qiskit patterns step 2: Transpilation

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

# Load the Runtime primitive and session
sampler = Sampler(mode=backend)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing
# Extract Bob's bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

# Compare Alice's and Bob's measurement bases and collect usable bits

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1

# Print some results

print("Alice's bits = ", agoodbits)
print("Bob's bits = ", bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Alice's bits =  [0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1]
Bob's bits =  [0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1]
fidelity =  0.9682539682539683
loss =  0.031746031746031744

Tanpa penyadapan, kita memperoleh fidelitas 100% untuk set 127 bit percobaan ini, menghasilkan 55 basis yang cocok dan bit kunci yang dapat digunakan. Sekarang mari kita ulangi eksperimen ini dengan Eve yang mendengarkan:

from qiskit_ibm_runtime import SamplerV2 as Sampler

# This calculation was run on an Eagle r3 processor on 11-7-24 and required 2 s to run, with 127 qubits.
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

bit_num = 127
qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# QKD step 1: Generate Alice's random bits and bases

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

# Eavesdropping happens here!
# Generate Eve's random measurement bases

ebase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if ebase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

sampler = Sampler(mode=backend)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing
# Extract Eve's bits

keys = counts.keys()
key = list(keys)[0]
emeas = list(key)
emeas_ints = []
for n in range(bit_num):
    emeas_ints.append(int(emeas[n]))
ebits = emeas_ints[::-1]

# print(ebits)

# Restart process
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

# QKD step 1: Eve uses her measurements above to prepare best guess states to send on to Bob

qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Eve's state preparation

for n in range(bit_num):
    if ebits[n] == 0:
        if ebase[n] == 1:
            qc.h(n)
    if ebits[n] == 1:
        if ebase[n] == 0:
            qc.x(n)
        if ebase[n] == 1:
            qc.x(n)
            qc.h(n)

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit Patterns step 4: Post-processing
# Extract Bob's bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

# Compare Alice's and Bob's bases, when they are the same, keep the bits.

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1

# Print some results

print("Alice's bits = ", agoodbits)
print("Bob's bits = ", bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Alice's bits =  [1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1]
Bob's bits =  [1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1]
fidelity =  0.7619047619047619
loss =  0.23809523809523814

Di sini kita menemukan hampir 23% kehilangan fidelitas pada bit yang dibagikan akibat penyadapan! Ini sangat bisa dideteksi! Perlu dicatat bahwa transmisi informasi kuantum jarak jauh tetap bisa memperkenalkan noise dan kesalahan tambahan. Memastikan bahwa penyadapan dapat dideteksi, bahkan di tengah noise, dan bahkan ketika Eve menggunakan semua trik yang dimilikinya, adalah bidang yang kompleks dan melampaui pengantar ini.

Pertanyaan

Instruktur dapat meminta versi notebook ini dengan kunci jawaban dan panduan penempatan dalam kurikulum umum dengan mengisi survei singkat ini tentang bagaimana notebook digunakan.

Konsep kritis

Informasi kuantum tidak dapat disalin atau "dikloning".
Kamu bisa mengulangi proses persiapan yang sama untuk membuat ensembel state kuantum yang semuanya sama, atau hampir sama.
Kunci enkripsi/dekripsi (one-time pad) bisa dibagikan antara dua teman menggunakan state kuantum.
Dua teman yang memilih basis pengukuran secara acak berarti setengah dari waktu mereka akan memilih berbeda, dan harus membuang informasi pada Qubit-Qubit tersebut.
Pilihan basis pengukuran yang acak juga memastikan bahwa penyadap tidak dapat mengetahui state awal yang disiapkan, dan dengan demikian tidak dapat merekonstruksi state yang dikirim. Ini memastikan penyadapan akan terdeteksi.

Pertanyaan B/S

B/S Dalam distribusi kunci kuantum, dua mitra yang berkomunikasi mengukur setiap Qubit dalam basis yang sama.
B/S Seorang penyadap yang mencegat informasi kuantum dalam QKD dicegah oleh hukum alam untuk menyalin state kuantum yang mereka cegat.
B/S One-time pad adalah kunci untuk mengenkripsi/mendekripsi pesan aman di mana skema pengkodean tertentu hanya digunakan sekali, untuk satu bagian informasi (seperti satu huruf alfabet).

Pertanyaan PG

Pilih opsi yang paling tepat melengkapi pernyataan berikut. Seperti yang dijelaskan dalam modul ini, one-time pad adalah sekumpulan kunci enkripsi/dekripsi yang digunakan...

a. Hanya sekali untuk satu bagian informasi, seperti satu huruf.
b. Hanya sekali untuk satu pesan.
c. Hanya sekali untuk periode waktu tertentu, seperti satu hari.
d. Sampai ada bukti penyadapan.

Asumsikan Alice dan Bob memilih basis pengukuran mereka secara acak. Mereka melakukan pengukuran. Kemudian mereka berbagi basis pengukuran, dan hanya menyimpan bit informasi dari kasus-kasus di mana mereka menggunakan basis yang sama. Dengan mempertimbangkan fluktuasi acak, kira-kira berapa persen Qubit mereka yang menghasilkan bit informasi yang dapat digunakan?

a. 100%
b. 50%
c. 25%
d. 12,5%
e. 0%

Setelah Alice dan Bob memilih kasus-kasus di mana mereka menggunakan basis pengukuran yang sama, berapa persen bit informasi tersebut yang seharusnya cocok, jika noise dan kesalahan kuantum diabaikan?

a. 100%
b. 50%
c. 25%
d. 12,5%
e. 0%

Asumsikan Alice telah memilih basis pengukurannya secara acak. Eve juga memilih basisnya secara acak, dan dia mendengarkan (mengukur). Eve mengirimkan state ke Bob yang konsisten dengan pengukurannya. Alice dan Bob membandingkan pilihan basis dan hanya menyimpan Qubit yang diukur/disiapkan oleh mereka dalam basis yang sama. Dengan mempertimbangkan fluktuasi acak, kira-kira berapa persen pengukuran Qubit yang disimpan tersebut yang akan cocok, menurut Alice dan Bob?

a. 100%
b. 75%
c. 50%
d. 25%
e. 12,5%
f. 0%

Pertanyaan diskusi

Asumsikan semua pilihan basis adalah acak untuk semua peserta, Alice, Bob, dan Eve. Asumsikan bahwa setelah Eve mendengarkan, dia mengirimkan state ke Bob yang disiapkan dalam basis yang sama dengan basis pengukurannya, dan yang konsisten dengan pengukuran tersebut. Yakinkan rekan-rekanmu bahwa 12,5% dari semua Qubit yang diinisialisasi oleh Alice akan menghasilkan ketidakcocokan pengukuran antara Alice dan Bob, yang mengindikasikan adanya penyadapan (mengabaikan kesalahan dan noise kuantum). Petunjuk 1: Karena tidak ada basis yang lebih diutamakan, jika kamu mempertimbangkan hanya satu pilihan awal untuk Alice, rasionya untuk satu pilihan tersebut seharusnya sama dengan rasio untuk jumlah semua pilihan. Petunjuk 2: Mungkin tidak cukup hanya menghitung jumlah cara sesuatu bisa terjadi, karena beberapa hasil mungkin terjadi dengan probabilitas yang berbeda.
Asumsikan lagi bahwa semua pilihan basis adalah acak untuk semua peserta, Alice, Bob, dan Eve. Namun sekarang, pertimbangkan bahwa Eve bebas mengirimkan state apa pun yang dia suka setelah pengukurannya. Eve bahkan bisa mencoba mengirimkan state yang tidak konsisten dengan pengukurannya sendiri. Diskusikan dengan rekan/tetangga kamu apakah menurutmu ada pilihan basis yang bisa mengurangi persentase rata-rata Qubit yang mengindikasikan penyadapan kepada Alice dan Bob.

Source: IBM Quantum docs — updated 17 Apr 2026

English version on doQumentation — updated 7 Mei 2026

This translation based on the English version of approx. 27 Mar 2026

Pengenalan dan motivasi​

Penggantian sederhana​

Pertanyaan check-in​

One-time pad​

Tindak lanjut​

Menggunakan keadaan kuantum sebagai kunci​

Cek pemahamanmu​

QKD langkah 1: Bit acak dan basis acak Alice​

QKD langkah 2: Basis acak Bob​

QKD langkah 3: Diskusi publik tentang basis​

QKD langkah 4: Verifikasi dan kirim rahasia​

Ketahanan QKD terhadap penyadapan​

Peringatan​

Eksperimen 1: QKD tanpa penyadap​

Pola Qiskit langkah 1: Petakan masalahmu ke Circuit kuantum​

Pola Qiskit langkah 2: Optimalkan masalah untuk eksekusi kuantum​

Pola Qiskit langkah 3: Eksekusi​

Pola Qiskit langkah 4: Pasca-pemrosesan​

Cek pemahamanmu​

Eksperimen 2: QKD dengan penyadap​

Eksperimen 3: Bandingkan QKD dengan dan tanpa penyadapan di komputer kuantum nyata​

Pertanyaan​

Konsep kritis​

Pertanyaan B/S​

Pertanyaan PG​

Pertanyaan diskusi​

Pengenalan dan motivasi

Penggantian sederhana

Pertanyaan check-in

One-time pad

Tindak lanjut

Menggunakan keadaan kuantum sebagai kunci

Cek pemahamanmu

QKD langkah 1: Bit acak dan basis acak Alice

QKD langkah 2: Basis acak Bob

QKD langkah 3: Diskusi publik tentang basis

QKD langkah 4: Verifikasi dan kirim rahasia

Ketahanan QKD terhadap penyadapan

Peringatan

Eksperimen 1: QKD tanpa penyadap

Pola Qiskit langkah 1: Petakan masalahmu ke Circuit kuantum

Pola Qiskit langkah 2: Optimalkan masalah untuk eksekusi kuantum

Pola Qiskit langkah 3: Eksekusi

Pola Qiskit langkah 4: Pasca-pemrosesan

Cek pemahamanmu

Eksperimen 2: QKD dengan penyadap

Eksperimen 3: Bandingkan QKD dengan dan tanpa penyadapan di komputer kuantum nyata

Pertanyaan

Konsep kritis

Pertanyaan B/S

Pertanyaan PG

Pertanyaan diskusi