Pengagihan kunci kuantum

Untuk modul Qiskit in Classrooms ini, pelajar perlu mempunyai persekitaran Python yang berfungsi dengan pakej-pakej berikut dipasang:

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

Untuk menyediakan dan memasang pakej di atas, rujuk panduan Pasang Qiskit. Untuk menjalankan kerja pada komputer kuantum sebenar, pelajar perlu membuat akaun dengan IBM Quantum® dengan mengikuti langkah-langkah dalam panduan Sediakan akaun IBM Cloud anda.

Modul ini telah diuji dan menggunakan 5 saat masa QPU. Ini adalah anggaran sahaja. Penggunaan sebenar anda mungkin berbeza.

# 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 panduan modul oleh Dr. Katie McCormick di bawah, atau klik di sini untuk menontonnya di YouTube.

---

Pengenalan dan motivasi

Terdapat cara yang tidak terhitung untuk menyulitkan dan menyahsulit maklumat, dan ribuan cara telah dikaji dengan mendalam. Di sini, kita akan mengehadkan diri kepada kaedah penyulitan yang sangat awal dan sangat mudah, iaitu "penggantian mudah", supaya kita boleh memberi tumpuan kepada bahagian kuantum protokol ini. Bahagian kuantum boleh disesuaikan dengan banyak protokol lain dengan perubahan yang agak sedikit.

Penggantian mudah

Penyulitan penggantian mudah ialah satu kaedah di mana satu huruf atau nombor digantikan dengan yang lain, sedemikian rupa sehingga terdapat pemetaan 1:1 daripada huruf dan nombor dalam mesej, kepada huruf dan nombor yang digunakan dalam jujukan yang disulitkan. Satu contoh dalam budaya popular ialah teka-teki cryptoquote atau cryptogram, di mana sebuah petikan atau frasa disulitkan menggunakan penggantian mudah, dan pemain perlu menyahsulitnya. Teka-teki ini mudah diselesaikan jika cukup panjang. Pertimbangkan 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 yang menyelesaikan teka-teki ini secara manual kebanyakannya menggunakan helah yang melibatkan kebiasaan dengan struktur bahasa mesej asal. Sebagai contoh, dalam bahasa Inggeris, satu-satunya perkataan satu huruf seperti "R" yang disulitkan ialah "a" dan "I". Huruf berganda yang disulitkan dalam, contohnya, "KIVGGB" hanya boleh mengambil nilai-nilai tertentu. Terdapat perkara-perkara yang lebih halus yang memberikan petunjuk seperti perkataan paling biasa yang sepadan dengan corak "GSZG" ialah "that". Orang yang menggunakan kod untuk menyelesaikan ini mempunyai lebih banyak pilihan, termasuk hanya mengimbas kemungkinan sehingga perkataan Inggeris ditemui, dan mengemas kini sambil mengekalkan perkataan itu. Satu kaedah yang mudah tetapi berkesan ialah menggunakan kekerapan huruf, terutamanya apabila mesej cukup panjang untuk menjadi sampel bahasa Inggeris yang representatif.

Soalan semak kendiri

Cuba tangan anda untuk menyahsulit ini jika mahu, walaupun ia tidak diperlukan untuk selebihnya modul. Klik anak panah di bawah untuk melihat mesej.

Jawapan:

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 "kunci", iaitu pemetaan daripada huruf yang disulitkan kepada huruf yang dinyahsulit. Dalam kes ini, kuncinya ialah:

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

Dan seterusnya. Mudah kata, ini bukan kunci yang baik. Kunci di mana huruf yang disulitkan dan dinyahsulit hanyalah versi beralih daripada abjad (seperti A->B dan B->C) dipanggil sifir "Caesar shift".

Perlu diingat bahawa ini sangat sukar jika teksnya pendek. Malah, jika teks itu sangat pendek, ia tidak boleh ditentukan. Pertimbangkan:

URYYP

Terdapat banyak kemungkinan penyahsulitan, menggunakan kunci yang berbeza: HELLO, PETTY, HAPPY, JIGGY, STOOL. Boleh kamu fikirkan yang lain?

Tetapi jika anda menghantar banyak mesej seperti ini, akhirnya, penyulitan akan dipecahkan. Jadi, anda tidak sepatutnya menggunakan "kunci" yang sama terlalu kerap. Malah, yang terbaik adalah jika anda menggunakan penggantian tertentu hanya sekali sahaja. Bukan hanya dalam satu mesej, tetapi hanya untuk satu aksara tunggal! Dengan ini, kami bermaksud anda akan mempunyai skim penyulitan atau kunci untuk setiap aksara yang digunakan dalam mesej, mengikut urutan. Jika anda ingin menghantar mesej kepada seorang rakan menggunakan cara ini, anda dan rakan anda memerlukan sekeping kertas (pada zaman dahulu) di mana kunci yang sentiasa berubah ini ditulis. Anda akan menggunakannya hanya sekali sahaja. Ini dipanggil "pad sekali guna" (one-time pad).

Pad sekali guna

Mari kita lihat bagaimana ini berfungsi dengan contoh. Ini boleh dilakukan sepenuhnya dengan huruf, tetapi adalah lazim untuk menukar daripada huruf kepada nombor, katakanlah, dengan menetapkan A=0, B=1, C=2…. Anggaplah kita adalah rakan-rakan yang terlibat dalam aktiviti sulit dan kita telah berkongsi pad. Sebaik-baiknya, kita akan berkongsi banyak pad, tetapi pad hari ini ialah:

EDGRPOJNCUWQZVMK…

Atau, menukarkan kepada nombor mengikut kedudukan dalam abjad:

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

Katakanlah, saya ingin berkongsi dengan anda, mesej berikut:

"I love quantum!"

Atau, setara dengan:

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

Kita tidak mahu menghantar kod di atas; itu adalah penggantian mudah, yang langsung tidak selamat. Kita mahu menggabungkan ini dengan kunci kita dengan cara tertentu. Cara yang biasa ialah penambahan modulo 26. Kita tambahkan nilai mesej dengan nilai kunci, mod 26, sehingga kita sampai ke penghujung mesej. Jadi, kita akan menghantar

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 bahawa jika seseorang memintas ini dan TIDAK mempunyai kunci, menyahsulitnya adalah mustahil sepenuhnya! Malah kedua-dua "u" dalam "quantum" tidak dikodkan dengan nombor yang sama! Yang pertama ialah 3, dan yang kedua ialah 16… dalam perkataan yang sama!

Jadi, saya hantar ini kepada anda, dan anda mempunyai kunci yang sama dengan saya. Anda membuat asal penambahan modulo 26 yang anda tahu saya 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),…

Supaya mesej x1, x2, x3, x4… mestilah

8, 11, 14, 21…

Akhirnya, menukarkan ini kepada teks, kita mendapat

"I love quantum".

Inilah pad sekali guna.

Perlu diingat bahawa jika kunci lebih pendek daripada mesej, kita mula mengulangi pengekodan kita. Itu masih merupakan masalah penyahsulitan yang sukar untuk diselesaikan, tetapi bukan mustahil jika ia diulang cukup banyak kali. Jadi, anda memerlukan kunci (atau "pad") yang panjang.

nota

Dalam banyak konteks, pelajar sudah biasa dengan penyulitan ini, sehingga aktiviti ini boleh dilangkau. Tetapi ini adalah peringatan semula yang agak cepat dan mudah.

Langkah 1: Dapatkan rakan, dan kongsi urutan 4 huruf untuk digunakan sebagai kunci. Mana-mana urutan 4 huruf yang sesuai untuk kelas boleh digunakan.
Langkah 2: Pilih perkataan rahsia 4 huruf yang anda mahu hantar kepada rakan anda (kedua-dua rakan melakukan ini supaya anda menghantar perkataan rahsia yang berbeza kepada satu sama lain)
Langkah 3: Tukarkan kunci/pad 4 huruf dan setiap perkataan rahsia 4 huruf kepada nombor menggunakan A = 1, B = 2, dan seterusnya.
Langkah 4: Gabungkan perkataan 4 huruf anda dengan pad sekali guna menggunakan penambahan modulo 26.
Langkah 5: Serahkan kepada rakan anda urutan nombor yang mengekodkan perkataan rahsia anda, dan rakan anda akan menyerahkan miliknya kepada anda.
Langkah 6: Nyahkod perkataan masing-masing menggunakan penolakan modulo 26.
Langkah 7: Sahkan. Adakah ia berjaya?

Soalan susulan

Tukar perkataan yang disulitkan dengan kumpulan lain, yang tidak mempunyai akses kepada pad sekali guna anda. Boleh anda menyahsulitnya? Terangkan mengapa atau mengapa tidak?

Diharapkan aktiviti di atas menjelaskan bahawa pad sekali guna adalah satu bentuk penyulitan yang tidak boleh dipecahkan, dengan beberapa andaian, seperti:

• Kunci mempunyai panjang yang sama dengan mesej yang dihantar, atau lebih panjang
• Kunci benar-benar rawak
• Kunci digunakan hanya sekali kemudian dibuang

Jadi, ini sangat bagus. Kita mempunyai penyulitan yang tidak boleh dipecahkan... melainkan seseorang mendapat kunci kita. Jika seseorang mendapat kunci kita, semua perkara akan terdedah. Perbezaan antara penyulitan yang tidak boleh dipecahkan dan semua rahsia kita terdedah menjadikan perkongsian kunci yang selamat amat penting. Matlamat pengagihan kunci kuantum adalah untuk memanfaatkan kekangan yang alam semula jadi telah kenakan ke atas maklumat kuantum bagi mengamankan kunci/pad sekali guna yang dikongsi.

Menggunakan keadaan kuantum sebagai kunci

Mari kita anggap kita bekerja dengan Qubit (menekankan bahawa Qubit mempunyai dua eigenstate). Seseorang boleh menggunakan sistem kuantum dengan bilangan keadaan kuantum yang lebih tinggi, tetapi komputer kuantum terkini di IBM® menggunakan Qubit. Tidak ada masalah untuk mengekodkan A, B, C kita kepada jujukan 0 dan 1. Jadi, sudah cukup bagi kita untuk berkongsi kunci yang terdiri daripada 0 dan 1 dan melakukan penambahan modulo 2 pada setiap bit yang menyimpan huruf.

Semak pemahaman anda

Baca soalan di bawah, fikirkan jawapan anda, kemudian klik segitiga untuk mendedahkan penyelesaian.

Jika kita benar-benar hanya mengambil berat tentang huruf Inggeris, berapa banyak bit yang kita perlukan?

Jawapan:

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

Rakan-rakan kita, Alice dan Bob ingin berkongsi kunci kuantum dengan cara yang tiada orang lain dapat memintas (sekurang-kurangnya tidak tanpa mereka mengetahuinya). Mereka perlu mempunyai cara untuk menghantar keadaan kuantum kepada satu sama lain. Melakukan ini dengan kesetiaan tinggi dan tanpa hingar/ralat TIDAK lah mudah. Tetapi terdapat dua pendekatan yang patut kita faham pada peringkat ini:

1. Kabel gentian optik membolehkan anda menghantar cahaya… yang sangat mekanik-kuantum. Foton tunggal boleh dikesan dengan kesetiaan tinggi melalui banyak kilometer kabel gentian optik. Ini bukan saluran kuantum yang sempurna dan bebas ralat, tetapi ia boleh sangat baik.
2. Kita boleh menggunakan teleportasi kuantum, seperti yang dihuraikan dalam modul sebelumnya. Iaitu, Alice dan Bob boleh berkongsi Qubit yang terjerat dan keadaan boleh dihantar dari Alice kepada Bob menggunakan protokol teleportasi.

Untuk modul ini, kita tidak mahu memerlukan anda mempunyai persediaan optik kesetiaan tinggi untuk berkongsi foton, jadi kita akan menggunakan kaedah kedua untuk berkongsi keadaan kuantum. Tetapi ini bukan bermakna ia adalah yang paling realistik untuk perkongsian kunci kuantum jarak jauh.

Kita kini akan meneroka protokol yang pertama kali digariskan oleh Charles Bennett dan Gilles Brassard pada tahun 1984 untuk berkongsi keadaan yang diukur dalam asas yang berbeza dari Alice kepada Bob. Kita akan menggunakan regimen pengukuran yang bijak untuk membina kunci yang akan digunakan dalam penyulitan kemudian. Dalam erti kata lain, kita mengagihkan kunci kuantum antara dua pihak yang ingin berkomunikasi, justeru "pengagihan kunci kuantum" (QKD).

Langkah QKD 1: Bit rawak dan asas rawak Alice

Alice akan mulakan dengan menjana jujukan rawak 0 dan 1. Dia kemudian akan memilih secara rawak asas untuk menyediakan keadaan kuantum, berdasarkan setiap bit rawak, menggunakan jadual di bawah (jadual yang juga dimiliki Bob):

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

Sebagai contoh, katakanlah Alice menjana secara rawak angka 0, dan memilih secara rawak asas X. Maka dia akan menyediakan keadaan kuantum $|\psi\rangle = |+\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. Seseorang pasti boleh memanfaatkan kerawakan kuantum untuk menjana set rawak 0 dan 1, dan pilihan asas yang rawak. Buat masa ini, mari kita hanya anggap set rawak telah dijana, seperti berikut:

Bit Alice	0	1	0	0	1	1	0	1	0	...
Asas 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$	...

Set bit rawak, asas, dan keadaan yang terhasil ini akan berterusan dalam jujukan panjang, untuk memberikan kunci yang cukup panjang.

Langkah QKD 2: Asas rawak Bob

Bob juga membuat pilihan asas secara rawak. Walau bagaimanapun, berbeza dengan Alice yang menggunakan pilihan asas untuk menyediakan keadaannya, Bob sebenarnya akan membuat pengukuran dalam asas-asas ini. Jika Bob membuat pengukuran dalam asas yang sama di mana Alice menyediakan keadaan tersebut, maka kita boleh meramalkan hasil pengukuran Bob. Apabila Bob kebetulan memilih asas yang berbeza daripada asas yang digunakan Alice dalam penyediaan, kita tidak dapat mengetahui hasil pengukuran Bob.

Bit Alice	0	1	0	0	1	1	0	1	0	...
Asas 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$	...
Asas 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 jadual di bawah, pertimbangkan lajur pertama. Alice telah menyediakan keadaan $\vert +\rangle,$ yang merupakan eigenstate bagi X. Memandangkan Bob juga telah memilih secara rawak untuk mengukur dalam asas X, hanya ada satu kemungkinan hasil untuk keadaan yang diukur Bob: $\vert +\rangle.$ Dalam lajur kedua, bagaimanapun, mereka telah memilih asas yang berbeza. Keadaan yang dihantar Alice ialah $\vert -\rangle = \frac{1}{\sqrt{2}}(\vert 0\rangle-\vert 1 \rangle).$ Ini mempunyai kemungkinan 50% untuk diukur oleh Bob dalam keadaan $\vert 0\rangle$, dan kemungkinan 50% untuk diukur dalam $\vert 1\rangle.$ Jadi baris yang menunjukkan apa yang kita ketahui, a priori, tentang pengukuran Bob tidak boleh diisi untuk lajur 2. Tetapi Bob akan membuat pengukuran dan mendapatkan eigenstate bagi (dalam lajur itu) Z. Dalam baris bawah, kita isi apa yang pengukuran-pengukuran ini kebetulan menghasilkan.

Langkah QKD 3: Perbincangan awam tentang asas

Alice dan Bob kini boleh berkongsi dengan satu sama lain asas yang mereka pilih dalam setiap kes. Untuk semua lajur di mana mereka kebetulan memilih asas yang sama, mereka masing-masing tahu dengan pasti keadaan apa yang dimiliki pihak yang lain. Bob boleh menukarkan keadaan dan asas kepada 0 atau 1 mengikut konvensyen yang dikongsi oleh kedua-dua pihak. Kita boleh menulis semula jadual di atas untuk hanya menunjukkan kes di mana asas Alice dan Bob sepadan:

Bit Alice	0	0	1	0	0	...
Asas Alice	X	Z	X	Z	X	...
Keadaan Alice	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Asas 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 berjaya menghantar rentetan bit 00100... kepada Bob. Jika rakan-rakan bersetuju lebih awal untuk menggunakan rentetan 5-bit sebagai nombor dalam pad sekali guna mereka, lima bit pertama ini akan memberikan mereka nombor $4 = 0\times2^4+0\times2^3+1\times2^2+0\times2^1+0\times2^0.$

Langkah QKD 4: Sahkan dan hantar rahsia

Sebelum Alice dan Bob meneruskan, mereka harus memilih subset bit klasik mereka untuk dibandingkan. Memandangkan mereka hanya menyimpan pengukuran Qubit yang disediakan dan diukur menggunakan asas yang sama, semua nilai yang diukur seharusnya bersetuju. Jika terdapat peratusan yang sangat kecil yang tidak bersetuju, ini boleh dikaitkan dengan hingar kuantum atau ralat. Tetapi jika banyak yang tidak bersetuju, sesuatu telah berlaku!

Di sini kita tidak akan membincangkan apakah peratusan kunci yang harus digunakan untuk pengesahan. Buat masa ini, kita akan anggap pemeriksaan ini berjalan dengan baik; kita akan meninjau semula ini dalam bahagian di bawah tentang pengintipan.

Rakan-rakan itu kemudian akan menghantar mesej yang disulitkan antara satu sama lain menggunakan saluran klasik. Mereka kemudian akan menggunakan nombor dalam pad sekali guna mereka untuk menyulitkan/menyahsulit mesej rahsia, tanpa pernah menghantar pad sekali guna dari satu lokasi ke lokasi lain. Untuk bahagian seterusnya tentang pengintipan, sila ingat bahawa semua perkongsian kunci ini berlaku sebelum pendedahan rahsia yang disulitkan melalui saluran klasik.

Alice dan Bob menyampaikan pilihan asas mereka melalui saluran klasik, jadi tidakkah itu boleh dipintas? Ya! Tetapi mengetahui asas yang mereka gunakan untuk pengukuran tidak memberitahu anda bit apa yang mereka hantar atau perolehi. Itu hanya mungkin jika anda juga mengetahui bit permulaan Alice. Tetapi ketika itu anda sudah berada dalam komputer Alice, di mana rahsia-rahsia disimpan, dan komunikasi rahsia rahsia-rahsia itu menjadi tidak bermakna. Jadi pemintasan komunikasi klasik tidak memecahkan penyulitan. Tetapi bagaimana dengan pemintasan maklumat dalam saluran kuantum?

Ketahanan QKD terhadap pengintipan

Alice dan Bob mempunyai seorang rakan bernama Eve, yang terkenal kerana suka mengintip. Eve ingin memintas kunci kuantum Alice dan Bob, supaya dia boleh menggunakannya untuk menyahsulit mesej yang dihantar antara mereka berdua. Ini semestinya akan berlaku antara penyediaan keadaan oleh Alice dan pengukuran keadaan oleh Bob, kerana pengukuran meruntuhkan keadaan kuantum. Khususnya, ini bermakna pengintipan harus berlaku sebelum berlakunya sebarang perkongsian atau perbandingan asas.

Eve mesti meneka asas mana yang digunakan untuk mengekodkan setiap bit. Sekali lagi, jika dia tidak dapat mengakses komputer Alice, dia tidak mempunyai apa pun untuk dijadikan asas tekaan ini, dan ia akan menjadi rawak. Mari kita anggap permulaan Alice adalah sama seperti sebelumnya, dan mari kita anggap lebih lanjut bahawa pilihan rawak asas pengukuran Bob adalah sama seperti sebelumnya. Mari kita isi apa yang Eve perolehi jika dia membuat pengukuran saluran kuantum. Seperti sebelumnya, jika Eve kebetulan memilih asas yang sama dengan Alice, kita tahu apa yang akan dia perolehi. Jika tidak, dia boleh memperoleh salah satu daripada dua hasil, masing-masing dengan kebarangkalian 50%.

Bit Alice	0	1	0	0	1	1	0	1	0	...
Asas 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$	...
Asas tekaan 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$	...
Asas Bob	X	Z	X	Z	X	X	Z	X	X	...

Kini kerana Eve tidak tahu sama ada dia memadankan asas Alice atau tidak, dia tidak tahu apa yang perlu dihantar kepada Bob untuk memadankan keadaan asal Alice. Apabila Eve mengukur, sebagai contoh, $|0\rangle,$ yang dia tahu dengan pasti hanyalah bahawa Alice tidak menyediakan keadaan $|1\rangle$ untuk Qubit itu. Tetapi Alice boleh sahaja menyediakan $|0\rangle,$ $|+\rangle,$ atau $|-\rangle.$ Semua boleh konsisten dengan pengukuran Eve. Jadi Eve mesti membuat pilihan. Dia mungkin menghantar terus keadaan yang dia ukur, atau dia mungkin cuba meneka kes-kes di mana pengukurannya bukan eigenstate yang dihantar Alice. Kita akan memasukkan campuran dalam jadual kita:

Bit Alice	0	1	0	0	1	1	0	1	0	...
Asas 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$	...
Asas tekaan 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 (dihantar)	$\vert 1\rangle$	$\vert 0\rangle$	$\vert 1\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	...
Asas 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 ketika ini, adalah wajar untuk bertanya, "Kenapa Eve tidak membuat salinan keadaan kuantum Alice, menyimpan satu untuk diukur, dan menghantar yang lain kepada Bob?" Jawapannya ialah "teorem tiada pengklonan" (no-cloning theorem). Secara tidak formal, ia menyatakan bahawa tiada operasi uniter (mekanik kuantum) yang boleh membuat salinan kedua bagi keadaan kuantum sewenang-wenangnya, sambil mengekalkan salinan pertama. Buktinya agak mudah, dan dibiarkan sebagai latihan berpandu. Tetapi buat masa ini, fahamlah bahawa Eve membuat salinan keadaan kuantum adalah dilarang oleh undang-undang asas alam, dan ini adalah kekuatan utama QKD. Seperti sebelumnya, Alice dan Bob akan menghubungi satu sama lain dan membandingkan asas. Mereka akan mengurangkan jadual ini kepada kes di mana kedua-dua rakan memilih asas yang sama:

Bit Alice	0	0	1	0	0	...
Asas Alice	X	Z	X	Z	X	...
Keadaan Alice	$\vert +\rangle$	$\vert 0\rangle$	$\vert -\rangle$	$\vert 0\rangle$	$\vert +\rangle$	...
Asas tekaan 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 (dihantar)	$\vert 1\rangle$	$\vert 0\rangle$	$\vert +\rangle$	$\vert 0\rangle$	$\vert 0\rangle$	...
Asas 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 berkomunikasi rentetan bit... tetapi rentetan-rentetan itu tidak sepadan. Bit paling kiri dan bit tengah telah disongsangkan. Melihat jadual sebelumnya, anda boleh menjejaki ketidakpadanan ini kepada gangguan daripada Eve. Yang penting, perhatikan bahawa kita boleh membuat statistik tentang padanan antara rentetan bit kita sekarang, semasa menyediakan kunci, jauh sebelum berkongsi rahsia yang disulitkan. Alice dan Bob bebas menggunakan seberapa banyak bit pad sekali guna mereka yang mereka mahu untuk memeriksa keselamatan saluran mereka. Jika satu bit, atau peratusan yang sangat kecil bit tidak sepadan, ini mungkin boleh dikaitkan dengan hingar atau ralat. Tetapi peratusan ketidakpadanan yang besar menunjukkan pengintipan. Maksud "besar" di sini bergantung sedikit pada hingar dalam persediaan yang digunakan; apa yang ia bermakna untuk komputer kuantum IBM® dibincangkan di bawah apabila kita melaksanakan protokol ini. Jika ralat berlebihan dikesan, Alice dan Bob tidak berkongsi rahsia, dan mereka boleh mula mencari pengintip.

Amaran

Membuktikan keselamatan adalah sangat sukar. Malah protokol yang dihuraikan secara longgar di sini dicadangkan pada tahun 1984, dan tidak terbukti selamat sehingga 16 tahun kemudian Shor & Preskill, 2000. Terdapat banyak kehalusan yang di luar skop pengenalan ini. Tetapi kita akan menyenaraikan beberapa secara ringkas untuk menunjukkan bahawa topik ini lebih kompleks daripada yang digambarkan di sini.

• Saluran selamat: Apabila Alice menghantar Qubit-nya melalui beberapa persediaan kuantum (saluran), dan khususnya apabila dia menerima respons klasik kembali daripada seseorang, kita telah menganggap bahawa seseorang itu sebenarnya Bob. Jika Eve menyusup ke dalam persediaan ini sedemikian rupa sehingga semua komunikasi Alice sebenarnya berlaku dengan Eve, dan semua komunikasi Bob sebenarnya dilakukan dengan Eve, maka Eve secara berkesan telah mendapatkan kunci, dan boleh mengetahui rahsia. Seseorang mesti terlebih dahulu memastikan "saluran selamat", satu proses dengan set protokol yang berbeza yang tidak kita tangani di sini.
• Andaian tentang Eve: Untuk benar-benar membuktikan keselamatan, kita tidak boleh membuat andaian tentang tingkah laku Eve; dia sentiasa boleh menggagalkan jangkaan kita. Di sini, untuk memberikan contoh konkrit, kita membuat andaian. Sebagai contoh, kita mungkin menganggap bahawa keadaan yang Eve hantar kepada Bob sentiasa tepat sama dengan yang dia perolehi semasa pengukuran. Atau kita mungkin menganggap bahawa dia memilih secara rawak keadaan yang konsisten secara eksperimental dengan pengukurannya. Lebih asasnya, bahasa di sini menganggap bahawa Eve sebenarnya membuat pengukuran, berbanding dengan menyimpan keadaan pada sistem kuantum lain dan menghantar Qubit rawak kepada Bob. Andaian-andaian ini baik untuk memahami protokol, tetapi ia bermakna kita tidak membuktikan apa-apa dalam keumuman penuh.
• Pengukuhan privasi: Alice dan Bob tidak dikehendaki menggunakan kunci kuantum tepat seperti yang dihantar. Mereka boleh, sebagai contoh, menggunakan fungsi cincang pada kunci yang dikongsi. Ini akan mengeksploitasi fakta bahawa pengintip mempunyai pengetahuan yang tidak lengkap tentang kunci untuk menghasilkan kunci yang dikongsi yang lebih pendek, tetapi selamat.

Eksperimen 1: QKD tanpa pengintip

Mari kita laksanakan protokol di atas tanpa pengintip. Kita akan melakukan ini terlebih dahulu menggunakan simulator, semata-mata untuk memahami aliran kerja.

Pertama, nota tentang simulator kuantum: Kebanyakan masalah kuantum yang melibatkan lebih daripada ~30 Qubit tidak dapat disimulasikan oleh kebanyakan komputer. Tiada komputer klasik, superkomputer atau GPU yang boleh mensimulasikan julat penuh tingkah laku komputer kuantum 127-Qubit. Biasanya, motivasi untuk menggunakan komputer kuantum sebenar ialah Qubit yang banyak terjerat tidak dapat disimulasikan. Dalam kes ini, tiada keterjeratan Qubit, melainkan kita menggunakan skim teleportasi untuk memindahkan maklumat. Dalam kes ini, motivasi untuk menggunakan komputer kuantum sebenar adalah berbeza: ia adalah teorem tiada pengklonan. Komputer klasik yang mensimulasikan Qubit boleh menghantar maklumat tentang keadaan kuantum dari Alice kepada Bob, tetapi jika maklumat klasik ini dipintas, ia boleh mudah diduplikasi, dan Eve boleh menyimpan salinan yang sempurna, sambil menghantar yang lain kepada Bob. Ini tidak mungkin dengan keadaan kuantum sebenar.

IBM Quantum mengesyorkan menangani masalah pengkomputeran kuantum menggunakan rangka kerja yang kami panggil "corak Qiskit" (Qiskit patterns). Ia terdiri daripada langkah-langkah berikut.

• Langkah 1: Petakan masalah anda kepada Circuit kuantum
• Langkah 2: Optimumkan Circuit anda untuk dijalankan pada perkakasan kuantum sebenar
• Langkah 3: Laksanakan kerja anda pada komputer kuantum IBM menggunakan primitif Runtime
• Langkah 4: Proses pasca keputusan

Langkah corak Qiskit 1: Petakan masalah anda kepada Circuit kuantum

Dalam kes ini, pemetaan masalah kita kepada Circuit kuantum hanya perlu menyediakan keadaan Alice, dan kemudian memasukkan pengukuran Bob. Kita mulakan dengan pemilihan bit rawak dan asas rawak.

# 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 visualisasikan bit, asas, dan Circuit. Perhatikan bahawa kadang-kadang asas sepadan, dan kadang-kadang 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.]

Langkah corak Qiskit 2: Optimumkan masalah untuk pelaksanaan kuantum

Langkah ini mengambil operasi yang ingin kita lakukan dan menyatakannya dari segi fungsi komputer kuantum tertentu. Ia juga memetakan masalah kita kepada susun atur komputer kuantum.

Kita akan bermula dengan memuatkan beberapa pakej yang diperlukan untuk berkomunikasi dengan komputer kuantum IBM. Kita juga mesti memilih Backend untuk dijalankan. Kita boleh memilih Backend yang paling kurang sibuk, atau memilih Backend tertentu yang sifat-sifatnya kita tahu. Walaupun kita akan seketika menggunakan simulator, adalah penting untuk menggunakan model hingar yang munasabah dalam simulasi, dan adalah baik untuk memastikan aliran kerja sedekat mungkin dengan apa yang akan kita gunakan kemudian untuk komputer kuantum sebenar.

Terdapat kod di bawah untuk menyimpan kelayakan anda semasa penggunaan pertama. Pastikan anda memadam maklumat ini daripada notebook selepas menyimpannya ke persekitaran anda, supaya kelayakan anda tidak terdedah secara tidak sengaja apabila anda berkongsi notebook tersebut. Lihat Sediakan akaun IBM Cloud anda dan Mulakan perkhidmatan dalam persekitaran yang tidak dipercayai untuk panduan 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 kita memilih simulator dan model hingar.

# 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)

Langkah corak Qiskit 3: Laksanakan

Gunakan Sampler untuk menjalankan kerja anda, 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()

Langkah corak Qiskit 4: Pemprosesan pasca

Di sini kita mentafsir keputusan kita dan mengekstrak maklumat yang berguna. Kita mungkin cuba memvisualisasikan output Sampler kita, tetapi kita telah menggunakan Sampler dengan cara yang tidak konvensional. Daripada membuat banyak pengukuran Circuit kita dan membuat statistik tentang keadaan, kita telah membuat hanya satu pengukuran (pengukuran Bob). Mana-mana Qubit dengan keadaan yang disediakan dan diukur dalam asas yang sama harus mempunyai hasil yang deterministik, sehingga hanya satu pengukuran diperlukan. Qubit-qubit yang keadaannya disediakan dan diukur dalam asas yang berbeza (yang akan mempunyai hasil kebarangkalian dan memerlukan banyak pengukuran untuk ditafsirkan) tidak akan digunakan untuk membina pad sekali guna/kunci kita. Mari kita ekstrak senarai hasil pengukuran daripada rentetan bit ini. Berhati-hati untuk membalikkan urutan jika membandingkan dengan tatasusunan bit Alice yang kita gunakan untuk menjana 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 asas pengukuran yang dipilih secara rawak oleh Alice dan Bob. Ini adalah langkah 3 dalam protokol QKD kita (perbincangan awam tentang asas). Setiap kali mereka memilih asas yang sama untuk sesuatu Qubit, kita tambahkan bit yang dikaitkan dengan Qubit tersebut ke dalam senarai bit untuk menjana nombor dalam pad sekali guna. Apabila asas tidak sepadan, keputusan dibuang. Mari kita juga semak sama ada dua senarai bit bersetuju, atau jika ada kehilangan akibat hingar atau faktor lain.

# 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 mempunyai senarai bit, dan ia sepadan dengan ketepatan 100%. Mereka boleh menggunakannya untuk menjana nombor dalam pad sekali guna. Mereka kemudian boleh menggunakannya dalam langkah QKD 4: menghantar dan menyahsulit rahsia. Tatasusunan bit semasa terlalu pendek untuk menyahsulit apa-apa pun. Kita akan kembali kepada ini selepas memasukkan pengintipan.

Semak pemahaman anda

Baca soalan di bawah, fikirkan jawapan anda, kemudian klik segitiga untuk mendedahkan penyelesaian.

Anggap anda memerlukan digit yang cukup besar untuk membolehkan pengalihan huruf dalam abjad Inggeris sepanjang panjang penuh abjad itu, atau lebih, walaupun terdapat skim pengekodan lain yang mungkin. (a) Berapa huruf panjangkah mesej yang boleh dinyahsulit menggunakan bit dalam kunci di atas? (b) Perlukah jawapan anda bersetuju dengan rakan sekelas anda? Mengapa atau mengapa tidak?

Jawapan:

(a) Jawapannya bergantung pada berapa banyak asas yang dipilih secara rawak yang sepadan antara Alice dan Bob. Memandangkan terdapat peluang 50-50 lebih kurang bahawa asas akan sepadan untuk mana-mana Qubit yang diberikan, kita jangkakan hampir 10 bit kita akan berguna. 9 atau 11 adalah amat biasa. Malah 4 atau 15 tidak di luar kemungkinan. 5 bit diperlukan untuk mengalih dengan nombor yang lebih besar atau sama dengan panjang abjad Inggeris, bermakna anda boleh menggunakan pengalihan itu untuk satu huruf bagi setiap 5 bit yang anda ada. Jika anda mempunyai sekurang-kurangnya 5 bit yang dikongsi oleh Alice dan Bob, anda boleh mengekodkan satu huruf. Jika anda mempunyai sekurang-kurangnya 10, anda boleh mengekodkan 2 huruf, dan seterusnya. (b) Ia tidak perlu bersetuju, atas sebab-sebab yang digariskan dalam (a).

Eksperimen 2: QKD dengan pengintip

Kita akan melaksanakan protokol yang sama seperti sebelumnya. Kali ini, kita akan menyelitkan satu set ukuran 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 (pemprosesan selepas ukuran) adalah mudah dalam kes ini. Tidak perlu menggambarkan taburan ukuran, memandangkan kita hanya membuat satu ukuran sahaja. Eve mempunyai 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 perlu membina semula keadaan-keadaan untuk dihantar kepada Bob. Seperti yang diterangkan dalam pengenalan, dia tidak tahu sama ada dia meneka asas pengekodan dengan betul atau tidak, jadi dia tidak mampu menyediakan keadaan yang sama persis seperti yang dihantar. Dia boleh menganggap setiap pilihan asas adalah betul dan mengekod tepat apa yang diukurnya, atau dia boleh menganggap dia memilih asas yang salah dan memilih salah satu keadaan eigen bagi asas yang bertentangan. Di sini, untuk kesederhanaan, kita akan mengandaikan yang pertama. Kita melakukan ini dengan membina litar kuantum baharu sepenuhnya, mengulangi 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 sekarang:

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

Sebelum ini, terdapat padanan sempurna antara bit-bit dalam kunci Alice dan Bob. Kini, akibat gangguan Eve, kita dapat lihat bit-bit Alice dan Bob berbeza dalam 14% kes yang sepatutnya sepadan kerana Alice dan Bob memilih asas yang sama. Ini sepatutnya mudah dikesan oleh Alice dan Bob. Walau bagaimanapun, bergantung pada peratusan ralat seperti ini memang menetapkan had kepada berapa banyak hingar yang boleh kita toleransi dalam saluran kuantum.

Eksperimen 3: Bandingkan QKD dengan dan tanpa penyadapan pada komputer kuantum sebenar

Mari jalankan ini pada komputer kuantum sebenar. Dengan cara itu kita boleh memanfaatkan teorem tiada-pengklonan. Pada masa yang sama, komputer kuantum sebenar ada hingar, dan kadar ralat yang lebih tinggi berbanding komputer klasik. Jadi mari kita bandingkan kehilangan ketepatan bit kunci kita dengan dan tanpa penyadapan, untuk memastikan perbezaannya boleh dikesan apabila menggunakan komputer kuantum sebenar. Kita akan mulakan 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 mendapat ketepatan 100% ke atas set 127 bit percubaan ini, menghasilkan 55 asas yang sepadan dan bit kunci yang boleh digunakan. Sekarang mari ulang eksperimen ini dengan Eve mendengar:

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 dapati hampir 23% kehilangan ketepatan dalam bit yang dikongsi akibat penyadapan! Ini sangat mudah dikesan! Perhatikan bahawa memindahkan maklumat kuantum melalui jarak jauh masih boleh memperkenalkan hingar dan ralat tambahan. Memastikan bahawa penyadapan boleh dikesan, walaupun dengan kehadiran hingar, dan walaupun apabila Eve menggunakan semua helah yang ada padanya adalah bidang yang kompleks di luar pengenalan ini.

Soalan

Pengajar boleh meminta versi buku nota ini dengan kunci jawapan dan panduan penempatan dalam kurikulum biasa dengan mengisi tinjauan ringkas ini tentang cara buku nota digunakan.

Konsep kritikal

• Maklumat kuantum tidak boleh disalin atau "diklon".
• Kamu boleh mengulangi proses persediaan yang sama untuk membuat ensembel keadaan kuantum yang semuanya sama, atau hampir sama.
• Kunci penyulitan/penyahsulitan (pad sekali-guna) boleh dikongsi antara dua rakan menggunakan keadaan kuantum.
• Dua rakan yang memilih asas pengukuran secara rawak bermakna separuh daripada masa mereka akan memilih secara berbeza, dan perlu membuang maklumat pada Qubit tersebut.
• Pilihan asas pengukuran secara rawak juga memastikan penyadap tidak boleh mengetahui keadaan awal yang disediakan, dan dengan itu tidak boleh mencipta semula keadaan yang dihantar. Ini memastikan penyadapan akan dikesan.

Soalan B/S

1. B/S Dalam pengagihan kunci kuantum, dua rakan berkomunikasi mengukur setiap Qubit dalam asas yang sama.
2. B/S Penyadap yang memintas maklumat kuantum dalam QKD dihalang oleh undang-undang alam daripada menyalin keadaan kuantum yang mereka pintas.
3. B/S Pad sekali-guna adalah kunci untuk menyulitkan/menyahsulit mesej selamat di mana skim pengekodan tertentu hanya digunakan sekali, untuk satu keping maklumat (seperti satu huruf abjad).

Soalan aneka pilihan

1. Pilih pilihan yang paling melengkapkan pernyataan. Seperti yang diterangkan dalam modul ini, pad sekali-guna adalah satu set kunci penyulitan/penyahsulitan yang digunakan...

• a. Hanya sekali untuk satu keping maklumat, seperti satu huruf.
• b. Hanya sekali untuk satu mesej.
• c. Hanya sekali untuk tempoh masa tertentu, seperti sehari.
• d. Sehingga ada bukti penyadapan.

2. Anggap Alice dan Bob memilih asas pengukuran mereka secara rawak. Mereka mengukur. Kemudian mereka berkongsi asas pengukuran mereka, dan menyimpan hanya bit maklumat daripada kes di mana mereka menggunakan asas yang sama. Sehingga beberapa turun naik rawak, kira-kira berapa peratus Qubit mereka harus menghasilkan bit maklumat yang boleh digunakan?

• a. 100%
• b. 50%
• c. 25%
• d. 12.5%
• e. 0%

3. Selepas Alice dan Bob memilih kes di mana mereka menggunakan asas pengukuran yang sama, berapa peratus bit maklumat tersebut harus sepadan, jika hingar dan ralat kuantum boleh diabaikan?

• a. 100%
• b. 50%
• c. 25%
• d. 12.5%
• e. 0%

4. Anggap Alice telah memilih asas pengukurannya secara rawak. Eve juga memilih asasnya secara rawak, dan dia mendengar (mengukur). Dia menghantar keadaan kepada Bob yang konsisten dengan pengukurannya. Alice dan Bob membandingkan pilihan asas dan menyimpan hanya Qubit yang diukur/disediakan oleh mereka dalam asas yang sama. Sehingga beberapa turun naik rawak, kira-kira berapa peratus pengukuran Qubit yang disimpan itu akan sepadan, menurut Alice dan Bob?

• a. 100%
• b. 75%
• c. 50%
• d. 25%
• e. 12.5%
• f. 0%

Soalan perbincangan

1. Anggap semua pilihan asas adalah rawak untuk semua peserta, Alice, Bob, dan Eve. Anggap bahawa selepas Eve mendengar, dia menghantar keadaan kepada Bob yang disediakan dalam asas yang sama di mana dia mengukur, dan yang konsisten dengan pengukuran itu. Yakinkan rakan-rakanmu bahawa 12.5% daripada semua Qubit yang dimulakan oleh Alice akan menghasilkan ketidakpadanan pengukuran antara Alice dan Bob, menunjukkan penyadapan (mengabaikan ralat dan hingar kuantum). Petunjuk 1: Oleh kerana tiada asas yang lebih diutamakan, jika kamu mempertimbangkan hanya satu pilihan awal untuk Alice, nisbah untuk satu pilihan itu mestilah sama dengan nisbah untuk jumlah semua pilihan. Petunjuk 2: Mungkin tidak mencukupi untuk mengira bilangan cara sesuatu boleh berlaku, kerana sesetengah hasil mungkin berlaku dengan kebarangkalian yang berbeza.

2. Anggap sekali lagi bahawa semua pilihan asas adalah rawak untuk semua peserta, Alice, Bob, dan Eve. Tetapi sekarang, pertimbangkan bahawa Eve bebas untuk menghantar sebarang keadaan yang dia mahukan selepas pengukurannya. Dia bahkan boleh cuba menghantar keadaan yang tidak konsisten dengan pengukurannya sendiri. Bincangkan dengan rakan/jiran kamu sama ada kamu fikir ada pilihan asas yang boleh mengurangkan purata peratus Qubit yang menunjukkan penyadapan kepada Alice dan Bob.