Cara memprogram komputer kuantum - Bahagian 2

Kapal perang dengan pengukuran kuantum

Penyelidikan IBM https://www.flickr.com/photos/ibm_research_zurich/33072160062/

Artikel ini mempunyai 'Bahagian 2' dalam tajuk dengan alasan yang baik. Terdapat Bahagian 1, di mana kami melihat asas menulis dan menjalankan program kuantum.

Saya akan menganggap bahawa anda membaca sekurang-kurangnya separuh pertama sebelum datang ke sini.

Sebilangan besar pengetahuan pengekodan sebenar yang anda perlukan untuk tutorial ini diliputi kali terakhir. Artikel ini kebanyakannya akan menumpukan pada beberapa perkara yang boleh kita lakukan dengan perintah ini.

Cara melihat qubit

Dalam program kita mempunyai pemboleh ubah. Pada satu ketika kita perlu melihatnya.

Ini mungkin pada akhir program apabila kita mendapat hasilnya. Mungkin juga terjadi selama program, ketika kita menggunakan pemboleh ubah sebagai bagian dari pernyataan bersyarat. Walau apa pun, ia banyak berlaku. Dan semasa memprogram pemboleh ubah bukan kuantum, ini adalah proses yang agak tidak dapat dilihat.

Ini kerana pemboleh ubah bukan kuantum mempunyai nilai pasti. Melihat mereka hanya memberitahu kita, atau bahagian lain dari program, berapa nilainya. Tiada apa-apa mengenai pemboleh ubah itu sendiri akan berubah.

Ini tidak berlaku untuk pemboleh ubah kuantum, yang boleh mempunyai nilai tak tentu. Mereka dapat berada dalam superposisi kuantum yang disebut, yang memungkinkan mereka menyimpan banyak nilai bertentangan sekaligus.

Apabila kita melihat mereka, mereka harus melepaskan semua keanehan ini. Mereka terpaksa mengambil nilai yang pasti, dan kemudian memberitahu kami apa nilai itu. Oleh kerana ini bukan hanya proses pasif, ia perlu dipertimbangkan dengan teliti. Dan ia memerlukan nama. Kami memanggilnya pengukuran.

Dalam artikel ini kita akan meneroka beberapa sifat pengukuran. Kami juga akan menggunakannya sebagai asas mekanik permainan, dan melihat dengan tepat bagaimana memprogramkannya pada komputer kuantum. Pada akhirnya kita akan mempunyai versi baru Battleships.

Memetakan dunia qubit

Sebelum kita benar-benar mula mengukur qubit, kita harus cuba memahami dunia mereka sedikit lagi. Cara terbaik untuk memvisualisasikan qubit adalah menggunakan sfera. Mana-mana keadaan qubit yang sepadan dengan titik di permukaan sfera ini.

Negeri 0 dan 1 sama sekali berbeza, sama sekali terpisah. Mereka saling bertentangan antara satu sama lain. Oleh itu, mereka akan hidup di seberang bola. Kami biasanya memilih untuk meletakkan 0 di kutub utara dan 1 di selatan.

Mari pilih titik yang sama jarak antara keduanya, di suatu tempat di sepanjang khatulistiwa. Ia boleh berada di mana sahaja anda suka. Kami akan memanggilnya +. Kenapa +? Kenapa tidak?

Keadaan + juga mempunyai kebalikan, berbeza dengan 0 dari 1. Ini tinggal di seberang, yang juga akan menjadi titik di sepanjang khatulistiwa. Kami akan memanggil negeri ini -.

Dengan poin 0, 1, + dan - sekarang ditakrifkan, beberapa perkara lagi meminta perhatian kami. Ini adalah jarak yang sama antara 0 dan 1, dan juga jarak antara + dan -. Kami akan memanggilnya ↻ dan ↺. Kenapa? Kerana saya pernah melihat seorang lelaki yang tidak menulis The Da Vinci Code melakukannya, dan saya menyukainya.

Kami kini telah memetakan dunia qubit dengan enam mata. Ini bukan satu-satunya yang akan kita gunakan. Mereka hanyalah mercu tanda yang akan kami lalui.

Mengukur qubit

Apa-apa pengukuran hanya kita meminta qubit untuk memilih antara dua titik yang bertentangan di sfera.

Contoh klasik adalah untuk pasangan kegemaran negeri berlawanan: 0 dan 1. Kami meminta qubit untuk memilih antara keduanya. Sekiranya sudah berada dalam keadaan 0, ia akan menjadi 0. Satu qubit dalam keadaan 1 juga akan memberikan hasilnya 1. Untuk keadaan lain, hasilnya akan menjadi rawak, dengan pilihan terdekat adalah yang paling mungkin.

Di khatulistiwa, peluang 50/50 sama ada. Oleh itu, jika keadaan kita adalah + atau -, dan kemudian kita bertanya sama ada 0 atau 1, ia harus memilih satu atau yang lain dengan kebarangkalian yang sama.

Pengukuran berdasarkan 0 dan 1 mempunyai beberapa nama. Kita boleh menyebutnya pengukuran 0/1, untuk alasan yang jelas. Ia juga disebut pengukuran dasar Z, kerana hubungan khusus yang dinyatakan oleh 0 dan 1 dengan operasi yang disebut z. Lebih banyak lagi mengenai cerita itu lain kali.

Jenis pengukuran yang paling popular seterusnya adalah ukuran untuk + dan -. Saya akan menyebutnya pengukuran +/-, tetapi anda mungkin juga melihatnya disebut pengukuran asas X. Ia berfungsi dengan cara yang sama seperti sebelumnya, tetapi hanya untuk + dan - bukannya 0 dan 1. Oleh itu, jika anda memulakan dengan qubit dalam keadaan + dan melakukan pengukuran ini, anda akan mendapat hasilnya +. Tetapi jika anda memulakan dengan 0 dan mengemukakan soalan yang sama, ia akan memilih secara rawak.

Kami juga mempunyai ukuran untuk perkara panah pelik. Ini dipanggil pengukuran asas Y. Tidak ada yang suka pengukuran asas Y.

Sedikit hanya sedikit, walaupun kuantum

Pengukuran objek bukan kuantum adalah proses pasif. Ia memberitahu anda apa yang sedang dilakukan objek itu, tetapi tidak mengubahnya dengan cara apa pun. Mengukur perkara kuantum sangat berbeza. Pengukuran kuantum tidak hanya mengubah pengetahuan kita mengenai pemboleh ubah. Mereka mengubah pemboleh ubah itu sendiri.

Katakan anda mempunyai qubit dalam keadaan +, dan kemudian tanyakan apakah itu 0 atau 1. Apabila memberi anda hasil rawak, itu bukan hanya membuat anda tidak senang. Ini tidak memberitahu anda perkara karut kerana anda mengemukakan soalan yang salah. Sebaik sahaja ia memberi anda hasil, ia akan bertahan dengannya. Nilainya akan berubah untuk menggambarkan jawapannya. Sekiranya ia memberitahu anda 0, ia akan menjadi 0 untuk selama-lamanya (atau sekurang-kurangnya sehingga anda memusingkannya sekali lagi). Ia akan lupa bahawa ia pernah +.

Ini bermaksud bahawa qubit hanya dapat memastikan hasilnya untuk satu pengukuran. Sekiranya ia pasti tahu sama ada 0 atau 1, ia sama sekali tidak pasti sama ada itu + atau -, dan juga tidak pasti sama ada ia ↻ atau ↺. Qubit hanya mempunyai jumlah kepastian yang terbatas untuk dikelilingi, dibatasi oleh prinsip ketidakpastian Heisenberg.

Ini bererti bahawa kita hanya dapat sekali mendapatkan maklumat dari qubit. Sebaik sahaja kami mengeluarkan satu keputusan binari, semua perkara yang pernah diketahui sebelum pengukuran dilupakan. Ia hanya mengingati hasil yang diberikan kepada kita. Oleh itu, walaupun terdapat sebilangan besar keadaan qubit yang mungkin, kita hanya dapat mengeluarkan sedikit maklumat. Itulah sebabnya kami menganggapnya sebagai versi kuantum sedikit, dan bukan vektor kuantum atau vektor kuantum 3, dll.

Mekanik permainan

Kami akan membuat varian Battleships di mana akan ada dua jenis serangan: bom dan torpedo. Hanya satu serangan yang berjaya diperlukan untuk menenggelamkan kapal, tetapi mendapatkan serangan yang berjaya tidak semudah itu. Beberapa kapal mempunyai pertahanan hebat terhadap pesawat sehingga tidak ada bom yang akan menghampirinya. Yang lain hebat menghalau torpedo.

Untuk melaksanakannya pada komputer biasa, kita dapat menentukan dua pemboleh ubah boolean untuk setiap kapal. Yang satu akan memberitahu kita sama ada kapal itu kebal terhadap bom, dan yang lain untuk torpedo. Ini kemudian dapat diperiksa semasa serangan untuk melihat apakah kapal itu tenggelam atau tidak.

Sekiranya ini adalah implementasi yang kita gunakan, secara teori akan mungkin kapal kebal terhadap kedua jenis serangan tersebut. Ini adalah reka bentuk permainan yang buruk, kerana tidak mungkin satu pemain menang. Pelaksanaan yang baik perlu mengelakkan kapal tidak dapat dihancurkan.

Salah satu cara untuk mengelakkan pembuatan kapal tersebut adalah dengan beberapa baris kod mudah. Itu sebenarnya bukan gaya kita. Sebaliknya, kita akan memperbaikinya dengan mekanik kuantum!

Secara khusus, kami akan berusaha memasukkan dua booleans ini menjadi satu qubit. Oleh kerana ia tidak sesuai, kita akan mendapat beberapa tingkah laku kuantum yang menarik. Ini akan menambahkan beberapa permainan yang menarik untuk permainan, dan juga mengelakkan kapal tidak dapat dihancurkan.

Kami akan melaksanakannya dengan mengaitkan serangan bom dengan pengukuran 0/1. Sekiranya kita mendapat keputusan 1, kita mengatakan bahawa kapal itu tenggelam. Untuk 0 kami menyimpulkan bahawa kapal itu kebal terhadap serangan bom. Untuk torpedo, kita sebaliknya melakukan pengukuran +/-, dengan - menyiratkan kehancuran dan + menyiratkan kekebalan.

Kaedah ini menjadikan kapal tidak mungkin kebal terhadap kedua-dua jenis serangan tersebut. Sekiranya kita mengetahui bahawa kapal musuh kebal terhadap bom (iaitu, keadaannya 0), kita tahu bahawa kapal itu mesti benar-benar tidak pasti mengenai torpedo (hasil pengukuran +/-). Oleh kerana serangan bom pasti akan gagal, maka kita harus menyerang dengan torpedo seterusnya.

Ia kemudian mungkin membuktikan bahawa serangan torpedo gagal (keadaan menjadi + setelah pengukuran +/-). Kapal akan memutuskan yang pasti kebal terhadap mereka, dan serangan torpedo selanjutnya akan gagal. Tetapi semua harapan tidak hilang. Dengan menjadi yakin mengenai torpedo, ia menjadi tidak pasti mengenai bom. Menyerang dengan mereka seterusnya (membuat pengukuran 0/1) boleh membawa kemenangan.

Sekiranya serangan bom tidak berjaya, kita kembali ke torpedo, dan seterusnya. Taktik terbaik ialah terus beralih antara keduanya sehingga kapal akhirnya tenggelam.

Kami akan memulakan kapal kerana tidak pasti mengenai kekebalan mereka terhadap kedua-dua serangan tersebut. Ini dapat dilakukan dengan memulakan qubit di salah satu keadaan asas Y. Mari cari for. Ini sebenarnya keadaan yang kita temui di Bahagian 1, iaitu u3 (0,5 * pi, 0,0) 0, jadi kita sudah tahu bagaimana membuatnya.

Berurusan dengan qubit pendek

Melaksanakan permainan pada pemproses kuantum tidak semudah yang kita harapkan. Kami akan melihat semua masalah yang akan dihadapi, dan melihat bagaimana mengatasi masalah tersebut.

Anggaplah kapal diserang bom dan bertahan. Kemudian pada pusingan seterusnya ia terkena torpedo.

Sekiranya permainan dijalankan pada komputer biasa, dan disimulasikan menggunakan bit normal, pelaksanaannya akan sangat mudah. Kapal akan diinisialisasi ketika permainan dimulakan, dan kemudian menunggu di ingatan sehingga pemain memutuskan apa yang harus dilakukan dengannya. Setelah pemain menghantar bom, operasi yang sesuai akan digunakan untuk melihat apakah ia musnah. Sekiranya ia bertahan, ia menunggu lagi hingga serangan seterusnya.

Ini tidak akan berfungsi untuk kita. Qubits tidak boleh duduk menunggu masa manusia. Beberapa saat lebih daripada cukup masa untuk mereka hancur dan terbakar, sekurang-kurangnya dengan teknologi terkini.

Alternatifnya adalah dengan menjalankan proses kuantum baru setiap kali serangan dilakukan. Pekerjaan pertama akan diinisialisasi dengan keadaan ↻, sehingga hasilnya akan menjadi acak untuk pengukuran 0/1 (serangan bom) atau pengukuran +/- (serangan torpedo). Hasil pengukuran kemudian direkodkan dan disimpan dalam memori pada komputer biasa. Apabila serangan seterusnya berlaku, pekerjaan lain dibuat untuk melihat apa yang berlaku. Ini akan diinisialisasi dengan hasil pengukuran terakhir, dan terus berlanjut.

Melakukan pengukuran +/-

Setakat ini saya telah menulis banyak perkataan, tetapi tidak satu baris kod. Mari kita mulakan dengan mengingat bagaimana pengukuran 0/1 dilaksanakan dalam kod QASM.

ukur q [0] -> c [0];

Peranan c [0] di sini penting untuk dikaji semula. Ini adalah output dari proses pengukuran. Ia adalah bit normal di mana hasil pengukuran disimpan. Untuk pengukuran 0/1 hasilnya adalah 0 atau 1.

Ini semua sangat mudah untuk pengukuran 0/1. Tetapi ini adalah ukuran +/- yang sedang kita lihat sekarang. Bagaimana kita mendapatkan maklumat daripada salah satu daripadanya?

Kami masih mahu menyimpan hasilnya dalam bit biasa c [0]. Oleh kerana ia adalah bit normal, ia tidak mengetahui keadaan + dan - yang pelik. Ia hanya mengetahui binari biasa. Oleh itu, kami memilih untuk melaporkan hasil + sebagai c [0] = 0, dan - sebagai c [0] = 1. Fakta bahawa ini akan kelihatan sama dengan hasil pengukuran 0/1 tidak akan menjadi masalah. Seperti dalam program komputer mana pun, kita harus tahu apa yang telah kita atur, dan kita harus tahu bagaimana menafsirkan hasilnya.

Sekarang kita tahu bagaimana mendapatkan hasil dari pengukuran +/-. Tetapi kami belum mengetahui cara membuatnya. Ini kerana kita perlu licik mengenainya. Kita perlu menggodam proses yang melakukan pengukuran 0/1 dan menjadikannya sebagai +/- satu.

Kunci penggodaman kami adalah operasi yang disebut Hadamard. Menerapkan ini pada qubit q [0] dalam kod QASM kelihatan seperti ini.

hq [0];

Perintah yang kami gunakan di Python untuk menambahkan baris ini ke fail QASM yang disebut gridScript adalah

gridScript.h (q [0])

Kesan Hadamard adalah untuk menukar keadaan asas Z dengan asas X dan sebaliknya. Ia adalah putaran Sfera yang memusingkan keadaan qubit 0 menjadi +, dan + ke 0. Begitu juga, 1 dipusingkan ke - dan sebaliknya.

Ini bermaksud bahawa kisah yang dapat kita ceritakan mengenai qubit dari segi 0 dan 1 sebelum Hadamard, kita mesti bercerita dengan + dan - setelahnya. Dan apa-apa kisah + dan - menjadi salah satu dari 0 dan 1.

Inilah yang kita perlukan. Ini bermaksud bahawa pengukuran +/- pada qubit q [0] dapat dilakukan dengan kod QASM berikut.

hq [0]; ukur q [0] -> c [0]; hq [0];

Untuk mengetahui mengapa ini berfungsi, mari kita teliti beberapa contoh. Qubit q [0] akan dimulakan baru dinyatakan di masing-masing, dan akan sama dengan nilai awal lalai 0.

Contoh Sifar:

ukur q [0] -> c [0];

Qubit dimulakan dalam keadaan 0. Ia ditanya sama ada 0 atau 1 dan memberitahu c [0] jawapannya. Hasilnya akan sentiasa c [0] = 0.

Contoh Satu:

xq [0];
ukur q [0] -> c [0];

Qubit bermula dalam keadaan 0 dan kemudian dipusingkan ke 1. Kemudian ditanya sama ada 0 atau 1. Ia selalu menjawab 1.

Contoh +:

hq [0];
ukur q [0] -> c [0];

Qubit bermula dalam keadaan 0 dan segera dipusingkan ke +. Ia kemudian ditanya sama ada keadaannya 0 atau 1. Ia memilih satu atau yang lain secara rawak, dan keadaannya dikemas kini dengan jawapannya.

Sekarang kita telah melakukan beberapa contoh remeh, mari kita lakukan sesuatu yang lebih kompleks.

Contoh ++:

hq [0];
hq [0]; ukur q [0] -> c [0]; hq [0];

Qubit bermula dalam keadaan 0 dan kemudian dipusingkan ke +. Selepas itu, ada dua cara yang setara untuk kita meneruskan cerita.

Salah satunya adalah bahawa ketiga-tiga baris terakhir secara kolektif membuat pengukuran +/-. Mereka bertanya apakah itu + atau -. Untuk + mereka mengembalikan hasil c [0] = 0, dan untuk - mereka mengembalikan c [0] = 1. Oleh kerana qubit masuk ke pengukuran dengan keadaan + dalam contoh ini, ia selalu diukur sebagai +. Oleh itu, ia keluar dari pengukuran yang masih dalam keadaan ini.

Untuk cerita lain, kita melihat kesan garis satu demi satu. Hadamard kedua membatalkan kesan yang pertama, dan seterusnya memutarkan qubit kembali ke keadaan 0. Kemudian ditanya apakah keadaannya 0 atau 1, dan selalu menjawab 0. Hadamard selanjutnya memutarkannya lagi ke +.

Kedua-dua cerita bersetuju mengenai kesan yang dapat dilihat. Mereka bersetuju bahawa output c [0] akan selalu 0, dan mereka bersetuju bahawa keadaan qubit pada akhir akan menjadi +. Mereka tidak bersetuju bagaimana ia berlaku. Kedua-dua tafsiran itu sama berlaku.

Sekiranya anda mahukan beberapa jargon untuk melihat sesuatu di Wikipedia, ini adalah contoh gambar Schrödinger dan Heisenberg mekanik kuantum.

Contoh +1:

xq [0];
hq [0]; ukur q [0] -> c [0]; hq [0];

Berikut adalah contoh lain yang mana kita mempunyai dua kisah yang setara. Kita boleh mengatakan bahawa q [0] dimulakan sebagai 0 dan kemudian dipusingkan ke 1. Ini kemudian diputar t0 - sebelum menjalani pengukuran 0/1. Secara rawak memutuskan satu atau yang lain, memberikan output c [0] = 0 atau c [0] = 1 dan keadaannya dikemas kini dengan sewajarnya. Sekiranya ia memutuskan 0, Hadamard terakhir akan memutarkannya menjadi +. Jika tidak, ia akan berakhir sebagai -.

Sebagai alternatif kita boleh mengatakan bahawa setelah dipusingkan menjadi 1, qubit melalui pengukuran +/-. Ia memutuskan secara rawak antara dua pilihan ini, memberikan output c [0] = 0 untuk + dan c [0] = 0 untuk -. Keadaan dikemas kini dengan sewajarnya, berakhir di negeri + atau -.

Sekali lagi, kedua-dua kisah ini sama-sama berlaku dan menyetujui semua kesan yang dapat dilihat. Sekiranya kita ingin memikirkan tiga baris

hq [0]; ukur q [0] -> c [0]; hq [0];

sebagai pengukuran +/-, kami bebas untuk melakukannya. Sekiranya kita ingin menganggapnya sebagai Hadamard diikuti dengan pengukuran 0/1 diikuti oleh Hadamard, itu juga baik.

Ada satu perkara penting yang perlu diberi perhatian sebelum kita terus maju. API IBM pada masa ini tidak membiarkan kami melakukan apa sahaja setelah kami mengukurnya. Ini bukan peraturan umum untuk komputer kuantum. Biasanya kita mengharapkan dapat terus mengukur dan memanipulasi qubit selama yang kita mahukan. Tetapi kita tidak dapat melakukannya pada masa ini.

Ini tidak menimbulkan masalah kepada kita. Oleh kerana qubit tidak boleh duduk sementara pemain tetap membuat pilihan, kita sudah harus membuat keadaan sepenuhnya setelah setiap pusingan pengukuran. Hadamard kedua akan muncul dengan berkesan dalam pekerjaan seterusnya, berdasarkan versi negeri yang bereinkarnasi.

Semua ukuran lain yang mungkin dapat dicapai dengan peretasan yang serupa. Kita hanya perlu melakukan beberapa operasi terlebih dahulu untuk memberi petunjuk pengukuran alternatif kita, dan kemudian (jika API membenarkan) melakukan operasi sebaliknya setelah itu.

Berurusan dengan kesilapan

Teknologi kuantum semasa tidak sempurna. Para qubit tidak selalu melakukan apa yang sepatutnya. Sekiranya qubit anda adalah 0 dan anda membuat pengukuran 0/1, hasilnya harus selalu 0. Selalu. Tetapi dengan peranti kuantum terkini, ada kemungkinan 1. Itu mungkin kerana operasi x tersekat ketika kita tidak melihatnya. Ini mungkin kerana pengukuran itu menipu kita. Kejadian seperti ini jarang berlaku, tetapi ia berlaku.

Terdapat dua cara untuk mengatasi kesalahan tersebut. Salah satunya ialah mengabaikan mereka. Kita boleh menuliskannya dalam naratif permainan. Terdapat ribut besar di laut. Kadang kala ini menyebabkan kapal hancur akibat serangan walaupun kapal itu kebal. Atau bertahan dari serangan yang seharusnya memusnahkannya.

Cara kedua untuk mengatasi kesilapan adalah dengan berusaha menghilangkan kesannya. Sekiranya terdapat banyak qubit, kami dapat melakukan ini dengan pembetulan ralat kuantum. Malangnya, masih ada beberapa tahun lagi.

Sebaliknya kami akan membuat beberapa statistik. Untuk itu kita memerlukan kebarangkalian, yang kita dapat dengan menjalankan setiap pekerjaan berkali-kali dan melihat berapa kerap setiap hasil yang mungkin muncul.

Dalam kes yang tidak bersuara, kebarangkalian semuanya adalah 0%, 100% atau 50%. Hasilnya adalah mustahil (seperti mendapatkan 1 jika keadaan 0), pasti (seperti mendapatkan + jika keadaan +) atau rawak sepenuhnya (seperti mendapatkan 0 ketika keadaan +).

Kebisingan sedikit sebanyak akan mengacaukannya. Apabila kita melakukan pengukuran 0/1 dari 0, kita mungkin mendapati bahawa hasil 0 hanya terjadi 98% dari waktu, dengan 2% untuk 1 sebagai gantinya. Untuk membetulkannya, kita akan melakukan sesuatu yang sewenang-wenangnya. Kami akan memutuskan bahawa apa-apa dengan kebarangkalian kurang dari 5% tidak akan pernah berlaku. Apa-apa dengan kebarangkalian lebih dari 95% semestinya sudah pasti.

Menggabungkan semuanya

Artikel ini telah membahas pukulan mekanik permainan yang luas untuk versi Kapal Perang ini, dan cara menerapkannya dengan komputer kuantum. Daripada membincangkan semua butiran terperinci di sini, saya akan memberikannya untuk komen dalam kod sumber sebenar.

Sekiranya ada yang anda fikirkan memerlukan penjelasan lebih lanjut, sila beritahu saya.