🧦 👧🏼 ☢️ Buku "Pengembangan menggunakan komputer kuantum" 🕵🏿 👃🏼 👌🏿

Halo, habrozhiteli! Komputasi kuantum tidak hanya mengubah kenyataan! Sebuah industri yang benar-benar baru dilahirkan di depan mata kita untuk menciptakan yang tidak terpikirkan sebelumnya dan untuk mendevaluasi beberapa pencapaian di masa lalu. Buku ini membahas komponen paling penting dari komputer kuantum: qubit, gerbang logika, dan sirkuit kuantum, dan juga menjelaskan perbedaan antara arsitektur kuantum dan tradisional. Anda dapat bereksperimen dengan mereka secara gratis di simulator dan di perangkat kuantum nyata menggunakan IBM Q Experience.

Anda akan belajar bagaimana perhitungan kuantum dilakukan menggunakan QISKit (alat perangkat lunak untuk memproses informasi kuantum), SDK Python, dan API lainnya, khususnya QASM.

Terakhir, Anda akan mempelajari algoritme kuantum modern yang menerapkan keterjeratan, pembuatan bilangan acak, pencarian linier, faktorisasi bilangan bulat, dan lainnya. Anda akan berurusan dengan status Bell yang menggambarkan keterjeratan, algoritma Grover untuk pencarian linier, algoritma Shore untuk faktorisasi bilangan bulat, algoritme optimisasi, dan banyak lagi. .

Anda akan belajar: • Menjalankan program dari jarak jauh menggunakan Q Experience REST API. • Tulis algoritma yang memberikan kinerja tertinggi dibandingkan dengan analog untuk komputer tradisional. • Buat klien REST di Node.js untuk mengautentikasi, mendengarkan perangkat jarak jauh, meminta informasi tentang prosesor kuantum, mengontrol dari jarak jauh dan menjalankan eksperimen di cloud. • Gunakan teleportasi kuantum. Menggunakan perhitungan klasik dan keterikatan kuantum antara pengirim dan penerima, mentransmisikan keadaan pasti dari qubit (informasi kuantum). • Program dan mainkan versi kuantum Pertempuran Laut. • Gunakan Q Experience Composer untuk membuat program / eksperimen visual.

Kutipan. Teori Permainan: Dengan mekanika kuantum, keuntungan selalu ada di pihak Anda

Bab ini mengeksplorasi dua teka-teki permainan yang menunjukkan keunggulan algoritma kuantum yang mengesankan dibanding rekan-rekan klasik mereka.

Teka-teki koin palsu. Ini adalah masalah penimbangan klasik yang diajukan oleh ahli matematika E. Shell pada tahun 1945. Di dalamnya, dengan menggunakan skala laboratorium untuk penimbangan dalam jumlah terbatas, Anda perlu menentukan koin yang beratnya berbeda dari yang lain (salah).
Kotak ajaib Mermin - Perez. Ini adalah contoh telepati kuantum pseudo, atau kemampuan pemain untuk mencapai hasil yang hanya mungkin jika mereka membaca pikiran satu sama lain selama pertandingan.

Dalam kedua kasus tersebut, komputasi kuantum memberdayakan pemain dengan kemampuan semu-ajaib, seolah-olah mereka curang sepanjang waktu. Mari kita lihat bagaimana ini terjadi.

Teka-teki koin palsu

Pemain memiliki delapan koin dan skala laboratorium. Salah satu koin itu palsu dan karena itu beratnya kurang dari yang lain. Bisakah kamu menemukannya? Mari kita lihat solusi yang ditunjukkan pada gambar. 7.1.

1. Letakkan koin 1-3 di sisi kiri skala, dan 4-6 di sebelah kanan. Sisihkan koin 7 dan 8.

2. Jika sisi kanan timbangan melebihi, maka salah - di antara koin 1-3 (di sebelah kiri). Ingat bahwa koin palsu lebih mudah. Kemudian keluarkan koin 3 dan letakkan koin 1 di sisi kiri skala dan koin 2 di sebelah kanan.

Jika mangkuk kanan melebihi beratnya, maka koin palsu 1.
Jika mangkuk kiri melebihi beratnya, maka koin palsu - 2.
Jika saldo seimbang, maka koin palsu 3.

3. Jika sisi kiri skala telah melebihi, maka yang salah - di antara koin 4–6. Lepaskan koin 6 dan letakkan koin 4 di sisi kiri skala dan koin 5 di sebelah kanan.

Jika mangkuk kanan melebihi beratnya, maka koin palsu 4.
Jika mangkuk kiri melebihi beratnya, maka yang palsu - koin 5.
Jika saldo seimbang, maka koin palsu 6.

4. Jika saldo seimbang, maka koin palsu adalah 7 atau 8. Letakkan koin 7 di sisi kiri skala dan koin 8 di sisi kanan dan timbang.

Jika mangkuk kanan melebihi beratnya, maka koin palsu 7.
Jika mangkuk kiri melebihi beratnya, maka koin palsu 8.

Algoritma klasik dapat diterapkan terlepas dari jumlah total koin N dan jumlah koin palsu k. Secara umum, kompleksitas waktu untuk masalah koin palsu umum adalah O (k log (N / k)).

CATATAN
Telah terbukti bahwa setidaknya dua upaya diperlukan untuk mendeteksi satu koin palsu menggunakan saldo laboratorium di komputer klasik.

Solusi Kuantum

Percaya atau tidak, ada algoritma kuantum yang dapat menemukan koin palsu dalam satu kuantum, terlepas dari jumlah koin N! Secara umum, untuk sejumlah koin palsu k, terlepas dari N, kompleksitas waktu dari algoritma tersebut adalah gambar

CATATAN
Algoritma kuantum untuk menentukan koin palsu adalah contoh percepatan tingkat empat dibandingkan dengan rekanan klasiknya.

Jadi, dalam gambar. 7.2 menunjukkan keunggulan dari algoritma kuantum di atas counterpart klasik dalam menyelesaikan teka-teki koin palsu. Mari kita pertimbangkan lebih terinci. Algoritma pencarian kuantum untuk satu koin palsu gambar

dapat dibagi menjadi tiga tahap: permintaan bobot kuantum, pembuatan bobot kuantum, dan definisi koin palsu.

Langkah 1. Minta bobot kuantum

Algoritma kuantum akan menanyakan bobot kuantum dalam superposisi. Untuk melakukan ini, gunakan string kueri biner untuk menyandikan koin pada skala. Misalnya, string kueri 11101111 berarti bahwa semua koin ada dalam skala, kecuali koin dengan indeks 3. Skala tersebut seimbang jika tidak ada koin palsu, dan dimiringkan sebaliknya. Ini diilustrasikan dalam tabel berikut.

Algoritma tindakan adalah sebagai berikut.

1. Gunakan dua register kuantum untuk kueri bobot kuantum, di mana register pertama adalah untuk string kueri dan yang kedua untuk hasilnya.

2. Mempersiapkan superposisi dari semua string kueri biner dengan jumlah unit genap.

3. Untuk mendapatkan superposisi status dengan jumlah satuan, lakukan transformasi Hadamard di kondisi dasar dan periksa apakah bobot Hamming untuk | x | bahkan. Dapat ditunjukkan bahwa berat Hamming untuk | x | bahkan jika dan hanya jika x1 ⊕ x2 ⊕ ... ⊕ xN = 0.

Perhatikan
Berat Hamming (hw) string adalah jumlah karakter selain karakter nol dari alfabet yang digunakan. Misalnya, hw (11101) = 4, hw (11101000) = 4, hw (000000) = 0.

4. Terakhir, ukur register kedua. Jika suatu kondisi diamati gambar

, maka register pertama adalah superposisi dari semua string kueri biner yang diinginkan. Jika diterima gambar

, maka Anda perlu mengulangi prosedur sampai kondisi terpantau. gambar

Perhatikan bahwa dengan setiap pengulangan, probabilitas keberhasilan tepat 0,5. Namun, setelah beberapa kali pengulangan, kita bisa mendapatkan superposisi keadaan yang diinginkan. Listing 7.1 menunjukkan implementasi program kuantum untuk menanyakan bobot, dan diagram grafik yang sesuai ditunjukkan pada Gambar. 7.3.

CATATAN
Untuk menyederhanakan persepsi, program untuk menentukan koin palsu dibagi menjadi daftar 7.1-7.3. Meskipun saya berharap Anda dapat menggabungkan daftar ini untuk menjalankan program, kode lengkapnya ada di sumber dalam file Workspace\Ch07\p_counterfeitcoin.py.

Daftar 7.1. Skrip Kueri Bobot Kuantum

# -------    
Q_program = QuantumProgram()
Q_program.set_api(Qconfig.APItoken, Qconfig.config["url"])

#  numberOfCoins +1 / 
#      
#  
qr = Q_program.create_quantum_register("qr", numberOfCoins + 1)

#     qr
cr = Q_program.create_classical_register("cr", numberOfCoins + 1)

circuitName = "QueryStateCircuit"
circuit = Q_program.create_circuit(circuitName, [qr], [cr])

N = numberOfCoins

#       N
for i in range(N):
     circuit.h(qr[i])

#  XOR(x)     CNOT  qr[0]
#  qr[N–1]     qr[N]
for i in range(N):
     circuit.cx(qr[i], qr[N])

#  qr[N]     cr[N]. ,
#  cr[N]  ,     
circuit.measure(qr[N], cr[N])

#     ,     
# cr[0]...cr[N],     |1>,
#   |0> - |1>  qr[N]
circuit.x(qr[N]).c_if(cr, 0)
circuit.h(qr[N]).c_if(cr, 0)

#      cr[N]
for i in range(N):
     circuit.h(qr[i]).c_if(cr, 2**N)

Dalam gbr. 7.3 adalah garis besar yang lengkap untuk puzzle koin palsu dengan delapan koin dan satu palsu dengan indeks 6. Ini menunjukkan semua langkah yang dijelaskan di sini untuk platform IBM Q Experience. Tahap kedua dari algoritma adalah penciptaan bobot.

Langkah 2. Membuat bobot kuantum

Di bagian sebelumnya, kami membuat superposisi dari semua string kueri biner yang bobot Hammingnya genap. Pada langkah ini, buat penyeimbang kuantum, atur posisi koin palsu. Jadi, jika k adalah posisi koin palsu relatif terhadap string biner, gambar

maka skala kuantum akan kembali:

Ini diimplementasikan menggunakan gerbang CNOT dengan xk sebagai qubit kontrol dan register kedua sebagai target (lihat Listing 7.2).

Listing 7.2. Membuat bobot kuantum

#-----   
k = indexOfFalseCoin

#       
# (  cr,  )
circuit.cx(qr[k], qr[N]).c_if(cr, 0)

Langkah 3. Identifikasi koin palsu

Untuk mengungkapkan koin palsu setelah kueri ke bobot, terapkan transformasi Hadamard ke string kueri biner. Diasumsikan bahwa kita membuat kueri pada bobot kuantum dengan string biner dengan bobot Hamming yang merata, oleh karena itu, setelah melakukan pengukuran dalam basis komputasi setelah transformasi Hadamard, kita dapat menentukan koin palsu, karena hanya labelnya yang berbeda dari kebanyakan label (lihat Listing 7.3).

Daftar 7.3. Definisi koin palsu

# ---   
#     qr[0] ... qr[N-1]
for i in range(N):
     circuit.h(qr[i]).c_if(cr, 0)

#  qr[0] ... qr[N–1]
for i in range(N):
     circuit.measure(qr[i], cr[i])

results = Q_program.execute([circuitName], backend=backend, shots=shots)
answer = results.get_counts(circuitName)

print("Device " + backend + " counts " + str(answer))

#     
for key in answer.keys():
     normalFlag, _ = Counter(key[1:]).most_common(1)[0]

for i in range(2,len(key)):
     if key[i] != normalFlag:
          print("False coin index is: ", len(key) - i - 1)

Ketika bit paling kiri adalah 0, indeks koin palsu dapat ditentukan dengan menemukan yang beratnya berbeda dari yang lain. Misalnya, dengan N = 8 dan indeks koin palsu 6, hasilnya harus 010111111 atau 001000000. Perhatikan bahwa karena kami menggunakan cr [N] untuk mengontrol operasi sebelum dan setelah permintaan bobot:

jika bit paling kiri adalah 0, maka kami telah berhasil mengidentifikasi koin palsu;
jika bit paling kiri adalah 1, maka kami tidak mendapatkan superposisi yang diinginkan dan harus mengulangi proses itu lagi.

Saat Anda menjalankan program pada simulator IBM Q Experience jarak jauh, Anda akan mendapatkan hasil yang ditunjukkan dalam kode sumber buku Workspace\Ch07\p_counterfeitcoin.py. Perhatikan bahwa saya menggunakan Windows: Jika Anda tidak memiliki akses ke kode sumber buku, tetapi Anda masih ingin bereksperimen dengan skrip ini, kemudian letakkan potongan kode dari bagian sebelumnya dalam wadah skrip dari Listing 7.4 (periksa lekukan, fitur sintaksis Python ini sederhana gila). Listing 7.4. Wadah naskah utama untuk teka-teki koin palsu

c:\python36-64\python.exe p_counterfeitcoin.py
Device ibmq_qasm_simulator counts {'001000000': 1}
False coin index is: 6

import sys
import matplotlib.pyplot as plt
import numpy as np
from math import pi, cos, acos, sqrt
from collections import Counter
from qiskit import QuantumProgram
sys.path.append('../Config/')
import Qconfig

#      
import basic plot tools
from qiskit.tools.visualization import plot_histogram

def main(M = 16, numberOfCoins = 8 , indexOfFalseCoin = 6
      , backend = "local_qasm_simulator" , shots = 1 ):

      if numberOfCoins < 4 or numberOfCoins >= M:
           raise Exception("Please use numberOfCoins between 4 and ", M-1)
      if indexOfFalseCoin < 0 or indexOfFalseCoin >= numberOfCoins:
           raise Exception("indexOfFalseCoin must be between 0 and ",
           numberOfCoins-1)

      //   7.1–7.3 

#################################################
# main
#################################################
if __name__ == '__main__':
     M = 8                      #    
     numberOfCoins = 4          #  M-1,  M —   
     indexOfFalseCoin = 2             #   0, 1... numberOfCoins — 1

     backend = "ibmq_qasm_simulator"
     #backend = "ibmqx3"
     shots = 1                         #      

     main(M, numberOfCoins, indexOfFalseCoin, backend, shots)

Algoritma umum untuk sejumlah koin palsu

Untuk menyelesaikan teka-teki koin palsu, ahli matematika Terhal dan Smolin pada tahun 1998 menciptakan algoritma umum untuk sejumlah koin palsu (k> 1). Dalam implementasinya, model "B-oracle" ("balance oracle") digunakan, sementara:

pada input
string kueri dibuat, terdiri dari N tiga kali lipat bit sehingga dengan jumlah yang sama 1 dan –1;
jawabannya adalah sedikit seperti itu

CATATAN
Oracle adalah bagian dari algoritma, yang dianggap sebagai kotak hitam. Ini digunakan untuk menyederhanakan skema dan membandingkan kompleksitas algoritma kuantum dan klasik. Peramalan yang baik harus cepat, fleksibel, dan mudah diimplementasikan.

Contoh menggunakan B-oracle untuk dua koin palsu dengan k = 2 dan N = 6 ditunjukkan pada Gambar. 7.4.

Secara umum, teka-teki koin palsu adalah contoh khas percepatan algoritma kuantum dibandingkan dengan mitra klasik. Di bagian selanjutnya, kita akan membahas teka-teki pseudo-sihir aneh lainnya yang disebut "kotak ajaib Mermin - Perez".

tentang Penulis

Vladimir Silva lulus dari Middle State State University dengan gelar Master di bidang Ilmu Komputer. Selama lima tahun, ia bekerja di IBM sebagai Research Engineer, di mana ia memperoleh pengalaman yang kaya dalam komputasi terdistribusi dan GRID.

Vladimir memiliki banyak sertifikat, termasuk OCP (Oracle Certified Professional), MCSD (Microsoft Certified Solutions Developer) dan MCP (Microsoft Certified Professional). Dia juga penulis sejumlah besar artikel teknis untuk situs IBM developerWorks. Dia telah menulis buku-buku berikut: Komputasi Grid untuk Pengembang (Charles River Media), Platform Klien Kaya Eclipse Praktis (Apress), Game Android Pro (Apress) dan Game Android 4 Lanjutan (Apress).

Vladimir adalah pelari maraton yang rajin yang berpartisipasi dalam 16 balapan di North Carolina (pada saat penulisan). Dia suka bermain gitar klasik dan merenungkan hal-hal menakjubkan seperti mekanika kuantum.

Tentang editor sains

Edisi Asli

Jason Whitehorn adalah pengusaha dan pengembang perangkat lunak yang berpengalaman. Dia telah membantu banyak perusahaan minyak dan gas mengotomatisasi dan meningkatkan teknologinya melalui pengumpulan data operasional, SCADA (Pengawasan Kontrol dan Akuisisi Data) dan pembelajaran mesin. Jason lulus dari Arkansas State University dengan gelar sarjana di bidang Ilmu Komputer.

Jason suka menghabiskan waktu luang bersama istri dan empat anaknya. Tinggal di Tulsa, Oklahoma. Informasi lebih lanjut tentang Jason dapat ditemukan di situs web jason.whitehorn.us .

Edisi Rusia

Mikhail Korobko- seorang fisikawan, terlibat dalam teori dan percobaan tentang penerapan optik kuantum, optomekanik dan pengukuran kuantum untuk meningkatkan sensitivitas detektor gelombang gravitasi. Sejak 2012, ia telah menjadi anggota kolaborasi ilmuwan internasional di detektor gelombang gravitasi LIGO.

Mikhail lulus dari Departemen Fisika Universitas Negeri Moskow. Lomonosov, saat ini adalah mahasiswa pascasarjana dari Institut Fisika Laser di Universitas Hamburg. Dia menghabiskan waktu luangnya bersama keluarganya, menulis artikel sains populer tentang fisika kuantum dan menerbitkan posting di Twitter (@hbar_universe).

»Informasi lebih lanjut tentang buku ini dapat ditemukan di situs web penerbit
» Daftar Isi
» Kutipan

untuk Penabung Tabungan Kupon diskon 25% - Silva

Setelah pembayaran versi kertas buku, sebuah buku elektronik dikirim melalui email.

Buku "Pengembangan menggunakan komputer kuantum"