A. pyQuil

pyQuil adalah pustaka Python open source yang dikembangkan oleh Rigetti untuk membuat, menganalisis, dan menjalankan program kuantum. Ini dibangun berdasarkan bahasa Quil - bahasa terbuka instruksi kuantum (atau hanya bahasa kuantum ), yang dirancang khusus untuk komputer kuantum terdekat yang menjanjikan dan didasarkan pada model memori klasik / kuantum yang umum [24] (ini berarti bahwa kedua qubit dan bit klasik). pyQuil adalah salah satu perpustakaan inti yang dikembangkan di Forest, yang merupakan platform utama untuk semua perangkat lunak Rigetti. Hutan juga mencakup Grove dan Reference QVM, yang akan diuraikan nanti.

a. Persyaratan dan Instalasi

Menginstal dan menggunakan pyQuil membutuhkan versi Python 2 atau 3, meskipun Python 3 sangat dianjurkan, karena fungsi pengembangan di masa depan hanya akan mendukung Python 3. Selain itu, distribusi Python Anaconda direkomendasikan untuk berbagai dependensi modul Python, walaupun ini tidak diperlukan.

Cara termudah untuk menginstal pyQuil adalah dengan menggunakan perintah manajer paket Python. Pada prompt perintah Ubuntu Linux, masukkan

 pip install pyquil 

untuk pemasangan perangkat lunak yang berhasil. Atau, jika Anaconda diinstal, pyQuil dapat diinstal dengan mengetik

 conda install −c rigetti pyquil 

di baris perintah. Alternatif lain adalah mengunduh kode sumber dari repositori git dan menginstal perangkat lunak. Untuk melakukan ini, masukkan perintah berikut:

 git clone https://github.com/rigetticomputing/pyquil cd pyquil pip install −e 

Metode terakhir ini direkomendasikan untuk semua pengguna yang dapat berkontribusi pada pyQuil. Lihat panduan setoran GitHub untuk informasi lebih lanjut.

b. Dokumentasi dan Tutorial

pyQuil memiliki dokumentasi yang sangat baik yang diposting di Internet, dengan pengantar komputasi kuantum, instruksi instalasi, program dasar dan operasi gerbang, simulator yang dikenal sebagai mesin virtual kuantum (QVM), komputer kuantum nyata, dan bahasa Quil dengan kompiler. Dengan mengunduh kode sumber pyQuil dari GitHub, Anda juga akan mendapatkan folder dengan contoh di notebook Jupyter, contoh Python reguler dan program$$ $ inline $ \ textf {run_quil.py} $ inline $ , yang dapat menjalankan dokumen teks yang ditulis dalam Quil menggunakan mesin virtual kuantum. Terakhir, sebut Grove , satu set algoritma kuantum yang dibangun menggunakan pyQuil dan lingkungan Rigetti Forest.

c. Sintaks

Sintaks pyQuil sangat sederhana dan praktis. Elemen utama untuk merekam sirkuit kuantum adalah program dan dapat diimpor dari $$$\ smsf {pyquil.quil}$ . Operasi gerbang dapat ditemukan di $$$\ smsf {pyquil.gates}$ . Modul $$$\ smsf {api}$ memungkinkan Anda untuk menjalankan sirkuit kuantum di mesin virtual. Salah satu fitur bagus dari pyQuil adalah bahwa register qubit dan register klasik tidak harus didefinisikan apriori dan dapat dialokasikan secara dinamis dalam memori. Qubit dalam register qubit dirujuk oleh indeks (0, 1, 2, ...) dan juga untuk bit dalam register klasik. Dengan demikian, rangkaian generator acak dapat ditulis sebagai berikut:

 # random number generator circuit in pyQuil from pyquil.quil import Program import pyquil.gates as gates from pyquil import api qprog = Program() qprog += [gates.H(0), gates.MEASURE(0, 0)] qvm = api.QVMConnection() print(qvm.run(qprog)) 

Daftar 2. Kode PyQuil untuk generator angka acak.

Tiga baris pertama mengimpor minimum yang diperlukan untuk mendeklarasikan skema / program kuantum (baris 2), untuk melakukan operasi gerbang pada qubit (baris 3) [44] dan untuk mengeksekusi skema (baris 4). Di baris 6, program kuantum dibuat, dan di baris 7-8, daftar instruksi dikirimkan ke sana: pertama, bertindak di gerbang Hadamard $$$H$ di atas qubit di indeks 0, maka kita mengukur qubit yang sama menjadi bit klasik di bawah indeks 0. Baris 10 membuat koneksi dengan QVM, dan pada 11 hasil rangkaian kami diluncurkan dan ditampilkan. Program ini mencetak output standar pyQuil sebagai daftar daftar bilangan bulat: dalam kasus kami - $$$\ smsf {[[[0]]}$ atau $$$\ smsf {[[[1]]}$ . Secara umum, jumlah item dalam daftar eksternal adalah jumlah tes yang dilakukan. Angka integer dalam daftar internal adalah dimensi terakhir dalam register klasik. Karena kami hanya melakukan satu tes (ini ditunjukkan sebagai argumen dalam $$$\ smsf {api.QVMConnection.run}$ , yang diatur ke kesatuan secara default), kami hanya mendapatkan satu daftar internal. Karena dalam register klasik kami hanya memiliki satu bit, kami hanya mendapatkan satu integer.

d. Bahasa kuantum

Quil adalah bahasa instruksi kuantum, atau hanya bahasa kuantum yang mengirimkan perintah ke komputer kuantum. Ini mirip dengan assembler di komputer klasik. Inti dari sintaks Quil adalah $$$\ smsf {GATE index}$ dimana $$$\ smsf {GATE}$ adalah gerbang kuantum yang berlaku untuk qubit yang diindeks $$$\ textf {index}$ (0, 1, 2, ...). pyQuil memiliki fungsi untuk menghasilkan kode Quil dari program yang diberikan. Misalnya, dalam penghasil bilangan acak kuantum yang disebutkan di atas, kita dapat menambahkan baris:

 print(qprog) 

di akhir untuk mendapatkan kode diagram Quil, yang ditunjukkan di bawah ini:

 H 0 MEASURE 0 [0] 

Daftar 3. Kode quil untuk generator angka acak.

Mungkin jika seseorang mulai memahami Quil, tulis sirkuit kuantum dalam editor teks di Quil, dan kemudian jalankan sirkuit di QVM menggunakan program$$ $ inline $ \ textf {run_quil.py} $ inline $ . Anda juga dapat memodifikasi$$ $ inline $ \ textf {run_quil.py} $ inline $ untuk menjalankan sirkuit pada QPU. Perhatikan bahwa kompiler pyQuil (juga disebut kompilator Quil dalam dokumentasi) mengubah sirkuit yang diberikan menjadi kode Quil yang dapat dipahami oleh komputer kuantum nyata. Kami akan membahas ini secara lebih rinci di bagian III C.

f. Perangkat keras kuantum

Rigetti memiliki prosesor kuantum yang dapat digunakan oleh mereka yang meminta akses. Untuk meminta akses, Anda harus mengunjungi situs web Rigetti dan memberikan nama lengkap, alamat email, nama organisasi, dan deskripsi alasan untuk mengakses QPU. Setelah ini selesai, perwakilan perusahaan akan menghubungi Anda melalui email untuk menjadwalkan waktu untuk memberikan pengguna akses ke QPU. Keuntungan dari proses perencanaan ini berbeda dengan sistem antrian QISKit, yang akan dibahas kemudian, adalah bahwa banyak tugas dapat dilakukan dalam interval waktu terdistribusi dengan waktu eksekusi deterministik, yang merupakan kunci untuk algoritma variasional dan hybrid. Jenis-jenis algoritma ini mengirim data bolak-balik antara komputer klasik dan kuantum - kebutuhan untuk mengantri membuat proses ini lebih lama. Kerugian (mungkin) adalah bahwa tugas tidak dapat dilakukan kapan saja ketika QPU tersedia dan perlu untuk menunjukkan dan menyetujui waktu tertentu.

Menurut pengalaman penulis, karyawan siap membantu, dan prosesnya biasanya berhasil. Perangkat aktual, topologi yang ditunjukkan pada Gambar 2, terdiri dari 8 qubit dengan konektivitas tetangga terdekat. Kita akan melihat komputer ini secara lebih rinci di Bagian III B.

g. Simulator

Mesin Virtual Kuantum (QVM) adalah utilitas utama yang digunakan untuk menjalankan sirkuit kuantum. Program ini, ditulis untuk dijalankan pada prosesor klasik, menerima kode Quil dan mensimulasikan pengembangan suatu proses pada komputer kuantum nyata. Untuk terhubung ke QVM, Anda perlu mendaftarkan kunci API secara gratis di https://www.rigetti.com/forest dengan nama dan alamat email. Kemudian Anda akan menerima email yang berisi kunci API dan ID pengguna yang harus dikonfigurasi saat startup:

 pyquil−config−setup 

pada baris perintah (setelah menginstal pyQuil, tentu saja). Maka Anda akan diminta memasukkan kunci dari email.

Menurut dokumentasi, sebagian besar kunci API menyediakan akses ke QVM hingga 30 qubit, dan Anda dapat meminta akses ke lebih banyak qubit. Kunci API penulis memberikan akses ke 26 qubit (tidak ada pembaruan yang diminta).

Selain itu, perpustakaan Hutan berisi simulator lokal yang ditulis dalam Python dan open source, disebut sebagai Referensi QVM . Ini tidak seproduktif QVM, tetapi pengguna dapat menjalankan sirkuit dengan jumlah qubit yang dibatasi oleh jumlah memori pada mesin lokal. Biasanya, sirkuit dengan kurang dari 20 qubit dapat dijalankan pada berbagai peralatan. Referensi QVM harus diinstal secara terpisah, yang dapat dilakukan dengan $$$\ textf {pip}$ :

 pip install referenceqvm 

Untuk menggunakan Referensi QVM alih-alih QVM, cukup impor $$$\ smsf {api}$ dari $$$\ smsf {referenceqvm}$ bukannya pyQuil:

 import referenceapi.api as api 

B. QISKit

Quantum Information Software Kit, atau QISKit, adalah perangkat pengembangan perangkat lunak sumber terbuka (SDK) untuk bekerja dengan bahasa kuantum OpenQASM dan prosesor kuantum dalam platform IBM Q. Ini tersedia untuk bahasa Python, JavaScript, dan Swift, tetapi di sini kami hanya membahas Versi python.

a. Persyaratan dan Instalasi

QISKit tersedia di MacOS, Windows, dan Linux. Instalasi QISKit membutuhkan Python 3.5+. Komponen tambahan yang bermanfaat, tetapi tidak diperlukan adalah Notebook Jupyter untuk tutorial dan distribusi Python Anaconda 3, yang berisi semua dependensi yang diperlukan.

Cara termudah untuk menginstal QISKit adalah dengan menggunakan manajer paket pip untuk Python. Pada prompt perintah, untuk menginstal perangkat lunak, masukkan:

 pip install qiskit 

Harap perhatikan itu $$$\ textf {pip}$ secara otomatis memproses semua dependensi dan akan selalu menginstal versi terbaru. Pengguna yang mungkin tertarik berkontribusi pada QISKit dapat menginstal kode sumber dengan memasukkan yang berikut ini pada prompt perintah, diasumsikan bahwa git diinstal:

 git clone https://github.com/QISKit/qiskit−core cd qiskit−core python −m pip install −e 

Untuk informasi tentang setoran, lihat dokumentasi online panduan setoran di GitHub.

b. Bahan dokumentasi dan pelatihan

Dokumentasi QISKit dapat ditemukan di Internet di https://qiskit.org/documentation/ . Berisi instruksi instalasi dan konfigurasi, program sampel dan koneksi ke perangkat kuantum nyata, organisasi proyek, tinjauan QISKit, dan dokumentasi pengembang. Informasi dasar tentang komputasi kuantum juga dapat ditemukan untuk pengguna yang baru di bidang ini. Sumber yang sangat bagus adalah tautan ke SDK, tempat pengguna dapat menemukan informasi tentang dokumentasi kode sumber.

QISKit juga berisi sejumlah besar tutorial dalam repositori GitHub yang terpisah (mirip dengan pyQuil dan Grove). Ini termasuk negara yang terjerat; algoritma standar seperti Deutsch Jozh, algoritma Grover, estimasi fase dan transformasi kuantum Fourier; juga algoritma yang lebih kompleks, seperti memecahkan masalah nilai eigen variabel kuantum dan menerapkannya pada fermion Hamiltonians; dan bahkan beberapa permainan menyenangkan, seperti "pertempuran laut" kuantum. Selain itu, perpustakaan ACQUA (Algoritma dan Sirkuit untuk Aplikasi Quantum) berisi algoritma multidisiplin untuk kimia dan kecerdasan buatan dengan banyak contoh.

Ada juga dokumentasi yang sangat terperinci untuk masing-masing dari empat backend kuantum yang berisi informasi tentang konektivitas, waktu koherensi, dan waktu penggunaan gerbang. Terakhir, sebutkan situs web pengalaman pengguna dan panduan pengguna IBM Q. Situs web ini berisi antarmuka grafis untuk sirkuit kuantum di mana pengguna dapat menyeret gerbang ke sirkuit, yang berguna untuk menjelajahi sirkuit kuantum. Panduan pengguna berisi lebih banyak instruksi tentang komputasi kuantum dan bahasa QISKit.

c. Sintaks

Sintaksis QISKit dapat dilihat dalam program sampel berikut. Di sini, tidak seperti pyQuil, Anda harus secara eksplisit membedakan antara register kuantum dan klasik. Di bawah ini adalah program untuk skema nomor acak QISKit:

 # random number generator circuit in QISKit from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute qreg = QuantumRegister(1) creg = ClassicalRegister(1) qcircuit = QuantumCircuit(qreg , creg) qcircuit.h(qreg[0]) qcircuit.measure(qreg[0], creg[0]) result = execute(qcircuit, 'local qasm simulator').result() print(result.get_counts()) 

Daftar 4. Kode QISKit untuk generator angka acak.

Baris 2 mengimpor alat untuk membuat register kuantum dan klasik, sirkuit kuantum, dan fungsi untuk mengeksekusi sirkuit ini. Kemudian kita membuat register kuantum dengan satu qubit (baris 4), register klasik dengan satu bit (baris 5) dan sirkuit kuantum dengan kedua register ini (baris 6). Sekarang setelah sirkuit dibuat, kita mulai memberikan instruksi: pada baris 8 kita menerapkan gerbang Hadamard ke nol qubit dalam register kuantum kita (yang merupakan satu-satunya qubit dalam register kuantum); pada baris 9, kami mengukur qubit ini menjadi bit klasik yang diindeks oleh nol dalam register klasik kami (yang merupakan satu-satunya dalam register klasik) [45]. Sekarang setelah sirkuit kuantum dibangun, jalankan di jalur 11 dan cetak hasilnya di jalur 12. Dengan cara keluaran$$ $ inline $ \ textf {result.get_counts ()} $ inline $ kita mendapatkan "perhitungan" sirkuit, yaitu kamus data output dan berapa kali setiap hasil diterima. Untuk kasus kami, output yang mungkin hanya 0 atau 1, dan contoh dari output dari program di atas adalah $$$\ smsf {{'0': 532, '1': 492}}$ , yang menunjukkan bahwa kami mendapat 532 instance dari 0 dan 492 instance dari 1. (Secara default, jumlah siklus untuk memulai rangkaian disebut $$$\ textf {shots}$ dalam QISKit, adalah 1024.)

d. Bahasa kuantum

OpenQASM (bahasa assembler kuantum terbuka [25], yang bisa kita sebut QASM) adalah bahasa kuantum yang menyediakan instruksi untuk perangkat kuantum nyata yang mirip dengan assembler pada komputer klasik. Dasar dari sintaks QASM adalah $$$\ smsf {gate qubit}$ dimana $$$\ smsf {gate}$ mengatur operasi gerbang kuantum, dan $$$\ smsf {qubit}$ - qubit. QISKit memiliki fungsi untuk menghasilkan kode QASM dari suatu skema. Dalam skema angka acak di atas, kita bisa menambahkan garis.

 print(qcircuit.qasm()) 

di akhir untuk mendapatkan kode QASM untuk rangkaian yang ditunjukkan di bawah ini:

 OPENQASM 2.0; include ”qelib1.inc”; qreg q0[1]; creg c0[1]; h q0[0]; measure q0[0] −> c0[0]; 

Daftar 5. Kode OpenQASM untuk generator angka acak.

Dua baris pertama termasuk dalam setiap file QASM. Baris 3 (4) membuat register kuantum (klasik), dan baris 5 dan 6 memberikan instruksi untuk sirkuit. Di OpenQASM, Anda dapat menulis sirkuit kecil seperti ini, tetapi untuk sirkuit yang lebih besar, lebih baik menggunakan alat di QISKit untuk pemrograman komputer kuantum yang gratis dan efisien.

e. Perangkat keras kuantum

Ada sejumlah besar dokumentasi untuk backend kuantum yang didukung oleh QISKit. Perangkat ini termasuk IBMQX2 (5 qubits), IBMQX4 (5 qubits), IBMQX5 (16 qubits) dan QS1_1 (20 qubits, hanya tersedia untuk anggota Jaringan Q IBM). Dokumentasi untuk semua orang tersedia di GitHub. Kami akan melihat lebih dekat pada IBMQX5 di Bagian III B, topologi yang ditunjukkan pada Gambar 3.

f. Simulator

IBM , . , 12 , , 25 . , III D.

C. ProjectQ

ProjectQ — IBM, . ProjectQ Thomas Häner Damien S. Steiger Matthias Troyer ETH Zurich, .

a.

ProjectQ Python (2.7 3.4+). . $$$\textsf{pip}$ :

 python −m pip install −−user projectq 

( ). :

 git clone https://github.com/ProjectQ−Framework/ProjectQ cd projectq python −m pip install −−user 

, , . ProjectQ GitHub.

b.

ProjectQ . , . - ( , ). — / , . [18, 19] , , - .

c.

ProjectQ , . ProjectQ ( ProjectQ), — / . , :

 # random number generator circuit in ProjectQ from projectq import MainEngine import projectq.ops as ops eng = MainEngine() qbits = eng.allocate_qureg(1) ops.H | qbits[0] ops.Measure | qbits[0] eng.flush() print(int(qbits[0])) 

6. ProjectQ .

2 , 3 . 5 (engine) $$$\textsf{MainEngine}$ , 6 . 8 9 : 0, . « » . — $$$\textsf{operation | qubit}$ , $$$H|0>$ , . , /. pyQuil QISKit, ProjectQ . , $$$\textsf{qbits[0]}$ 9, , $$$\textsf{int}$ , 12.

d.

, ProjectQ . ProjectQ IBM, OpenQASM: IBM.

e.

ProjectQ . , IBM ProjectQ.

f.

ProjectQ , C++, , , Python. , ProjectQ $$$\textsf{ClassicalSimulator}$ (stabilizer circuits), . . , , , CNOT [26]. , , , , . , $$$\textsf{C++ Simulator}$ .

$$$\textsf{C++ Simulator}$ ProjectQ . [23]() (, ), 26 5 , 28 20 — . [III D]() 6.

h. ProjectQ

ProjectQ , , . , pyQuil ProjectQ [27], Microsoft QDK Thomas Häner Damian Steiger ETH Zurich [28], . ( , , QDK ProjectQ C++, .)

D. Quantum Development Kit

Rigetti IBM, Microsoft . [29] , , , . , Microsoft , Quantum Development Kit (QDK), , . , QDK «-» Q#, Visual Studio Visual Studio Code 30 . 2018 , -, MacOS, Windows Linux.

a.

, Visual Studio Code , . ( VS Code, Visual Studio . - - , , VS Code.) , QDK , Bash:

 dotnet new −i "Microsoft.Quantum.ProjectTemplates::0.2 −*" 

QDK GitHub ( , QDK), :

 git clone https://github.com/Microsoft/Quantum.git cd Quantum code 

b.

— Q#, - , , , Q# . ; , .

c.

Q# . C#: , Python, , C#. , :

 // random number generator circuit in QDK operation random (count: Int, initial: Result) : (Int, Int) { body { mutable numOnes = 0; using ( qubits = Qubit[1]) { for (test in 1..count) { Set(initial, qubits[0]); H(qubits[0]); let res = M(qubits[0]); // count the number of ones if (res == One) { set numOnes = numOnes + 1; } } Set(Zero, qubits[0]); } // return statistics return (count − numOnes, numOnes); } } 

7. Q# .

, , /, , . . , , , . — $$$\textsf{.qs}$ Q#, $$$\textsf{Driver.cs}$ $$$\textsf{.qs}$ , $$$\textsf{.csproj}$ , . , 65 . -, , «Quickstart» .

, QDK , . , — $$$(a + b)$ , . QDK , , ( C , , , , .

d. /

, QDK . Q# / .

e.

QDK , 30 . , QDK ProjectQ, , ProjectQ. ( III D.) Azure , 40 . QDK , .

, QDK (trace simulator), , , , . , . , . , , - , . . . - QDK.

1. Bernhard Ömer, A procedural formalism for quantum computing , Master's thesis, Department of Theoretical Physics, Technical University of Vienna, 1998.
2. S. Bettelli, L. Serafini, T. Calarco, Toward an architecture for quantum programming , Eur. Phys. J. D, Vol. 25, No. 2, pp. 181-200 (2003).
3. Peter Selinger (2004), A brief survey of quantum programming languages , in: Kameyama Y., Stuckey PJ (eds) Functional and Logic Programming. FLOPS 2004. Lecture Notes in Computer Science, vol 2998. Springer, Berlin, Heidelberg.
4. Benjamin P. Lanyon, James D. Whitfield, Geoff G. Gillet, Michael E. Goggin, Marcelo P. Almeida, Ivan Kassal, Jacob D. Biamonte, Masoud Mohseni, Ben J. Powell, Marco Barbieri, Alaґn Aspuru-Guzik, Andrew G. White, Towards quantum chemistry on a quantum computer , Nature Chemistry 2 , pages 106-111 (2010), doi:10.1038/nchem.483.
5. Jonathan Olson, Yudong Cao, Jonathan Romero, Peter Johnson, Pierre-Luc Dallaire-Demers, Nicolas Sawaya, Prineha Narang, Ian Kivlichan, Michael Wasielewski, Alaґn Aspuru-Guzik, Quantum information and computation for chemistry , NSF Workshop Report, 2017.
6. Jacob Biamonte, Peter Wittek, Nicola Pancotti, Patrick Rebentrost, Nathan Wiebe, Seth Lloyd, Quantum machine learning , Nature volume 549 , pages 195-202 (14 September 2017).
7. Seth Lloyd, Masoud Mohseni, Patrick Rebentrost, Quantum principal component analysis , Nature Physics volume 10 , pages 631-633 (2014).
8. Vadim N. Smelyanskiy, Davide Venturelli, Alejandro Perdomo-Ortiz, Sergey Knysh, and Mark I. Dykman, Quantum annealing via environment-mediated quantum diffusion , Phys. Rev. Lett. 118 , 066802, 2017.
9. Patrick Rebentrost, Brajesh Gupt, Thomas R. Bromley, Quantum computational finance: Monte Carlo pricing of financial derivatives , arXiv preprint (arXiv:1805.00109v1), 2018.
10. IM Georgescu, S. Ashhab, Franco Nori, Quantum simulation , Rev. Mod. Phys. 86, 154 (2014), DOI: 10.1103/RevModPhys.86.153.
11. EF Dumitrescu, AJ McCaskey, G. Hagen, GR Jansen, TD Morris, T. Papenbrock, RC Pooser, DJ Dean, P. Lougovski, Cloud quantum computing of an atomic nucleus , Phys. Rev. Lett. 120 , 210501 (2018), DOI: 10.1103/PhysRevLett.120.210501.
12. Lukasz Cincio, Yigit Subasi, Andrew T. Sornborger, and Patrick J. Coles, Learning the quantum algorithm for state overlap , arXiv preprint (arXiv:1803.04114v1), 2018
13. Patrick J. Coles, Stephan Eidenbenz, Scott Pakin, et al., Quantum algorithm implementations for beginners , arXiv preprint (arXiv:1804.03719v1), 2018.
14. Mark Fingerhuth, Open-Source Quantum Software Projects , accessed May 12, 2018.
15. Quantiki: List of QC Simulators , accessed May 12, 2018
16. R. Smith, MJ Curtis and WJ Zeng, A practical quantum instruction set architecture , 2016.
17. QISKit, originally authored by Luciano Bello, Jim Challenger, Andrew Cross, Ismael Faro, Jay Gambetta, Juan Gomez, Ali Javadi-Abhari, Paco Martin, Diego Moreda, Jesus Perez, Erick Winston, and Chris Wood, https://github.com/QISKit/qiskit-sdk-py .
18. Damian S. Steiger, Thomas Häner, and Matthias Troyer ProjectQ: An open source software framework for quantum computing , 2016.
19. Thomas Häner, Damian S. Steiger, Krysta M. Svore, and Matthias Troyer A software methodology for compiling quantum programs , 2016.
20. The Quantum Development Kit by Microsoft, homepage: https://www.microsoft.com/en — us/quantum/development-kit, github: https://github.com/Microsoft/Quantum .
21. Michael A. Nielsen and Isaac L. Chuang, Quantum Computation and Quantum Information 10th Anniversary Edition, Cambridge University Press, 2011.
22. Doug Finke, Education , Quantum Computing Report, https://quantumcomputingreport.com/resources/education/ , accessed May 26, 2018.
23. All code in this paper was run and tested on a Dell XPS 13 Developer Edition laptop running 64 bit Ubuntu 16.04 LTS with 8 GB RAM and an Intel Core i7-8550U CPU at 1.80 GHz. Programs were run primarily from the command line but the Python developer environment Spyder was also used for Python programs and Visual Studio Code was used for C# (Q#) programs.
24. Forest: An API for quantum computing in the cloud, https://www.rigetti.com/index.php/forest , accessed May 14, 2018.
25. Andrew W. Cross, Lev S. Bishop, John A. Smolin, Jay M. Gambetta, Open quantum assembly language , 2017.
26. Scott Aaronson, Daniel Gottesman, Improved Simulation of Stabilizer Circuits , Phys. Rev. A 70 , 052328, 2004.
27. pyQuil Lisence, github.com/rigetticomputing/pyquil/blob/master/LICENSE#L204 , accessed June 7, 2018.
28. Microsoft Quantum Development Kit License, marketplace.visualstudio.com/items/quantum.DevKit/license , accessed June 7, 2018.
29. Hao Zhang, Chun-Xiao Liu, Sasa Gazibegovic, et al. Quantized Majorana conductance , Nature 556 , 74-79 (05 April 2018).
30. 16-qubit backend: IBM QX team, “ibmqx5 backend specification V1.1.0,” (2018). Retrieved from https://ibm.biz/qiskit-ibmqx5 and https://quantumexperience.ng.bluemix.net/qx/devices on May 23, 2018.
31. Talia Gershon, Celebrating the IBM Q Experience Community and Their Research , March 8, 2018.
32. M. Reck, A. Zeilinger, HJ Bernstein, and P. Bertani, Experimental realization of any discrete unitary operator , Physical Review Letters, 73, p. 58, 1994.
33. Ryan LaRose, Distributed memory techniques for classical simulation of quantum circuits , arXiv preprint (arXiv:1801.01037v1), 2018.
34. Thomas Haner, Damian S. Steiger, 0.5 petabyte simulation of a 45-qubit quantum circuit , arXiv preprint (arXiv:1704.01127v2), September 18, 2017.
35. Jianxin Chen, Fang Zhang, Cupjin Huang, Michael Newman, Yaoyun Shi, Classical simulation of intermediate-size quantum circuits , arXiv preprint (arXiv:1805.01450v2), 2018.
36. Alwin Zulehner, Robert Wille, Advanced simulation of quantum computations , arXiv preprint ( arXiv:1707.00865v2 ), November 7, 2017.
37. Jarrod R. McClean, Ian D. Kivlichan, Kevin J. Sung, et al., OpenFermion: The electronic structure package for quantum computers , arXiv:1710.07629, 2017.
38. Nathan Killoran, Josh Izaac, Nicols Quesada, Ville Bergholm, Matthew Amy, Christian Weedbrook, Strawberry Fields: A Software Platform for Photonic Quantum Computing , arXiv preprint (arXiv:1804.03159v1), 2018.
39. IonQ website, https://ionq.co/ , accessed June 15, 2018.
40. D-Wave: The quantum computing company, https://www.dwavesys.com/home , accessed June 20, 2018.
41. 4 2018 Rigetti 20- , . , 8- «- ». , 20- (, , ).
42. IBMQ Network , 2017 — JP Morgan Chase , Daimler , Samsung , Honda , Oak Ridge National Lab , — , 2018 — Zapata Computing , Strangeworks , QxBranch , Quantum Benchmark , QC Ware , Q-CTRL , Cambridge Quantum Computing (CQC) , 1QBit . North Carolina State University , IBM Q Hub, University of Oxford University of Melbourne . https://www.research.ibm.com/ibmq/network/ .
43. , - - . QISKit, ACQUA , pyQuil.
44. pyQuil : , $$$\textsf{from pyquil.gates import H, MEASURE}$ . $$$\textsf{pyquil.gates}$ , , , .
45. , () . , () , , .
46. IBM, 31 2018 , « » Python Cython, .

A.

, . Players Quantum Computing Report [22]. , , . / — .

a. Strawberry Fields

Xanadu , , Strawberry Fields Python , [38]. Xanadu «qumodes» ( ), , , . Strawberry Fields Numpy TensorFlow, Blackbird. GitHub, , , , . , Xanadu https://www.xanadu.ai/ , .

b. IonQ

IonQ — -, College Park , . IonQ , . $$$^{171}$ Yb , IonQ T2 () 15- , T2 1 . , T1 ( ) 20 000 , $$$10^{-4}$ . , -- - , «» . , .

IonQ , IonQ . . , - [39].

c. D-Wave Systems

D-Wave [40], , . D-Wave, 1999 , , , ,

$$ $$\begin{equation*} H = \sum_{i} h_i \sigma_i^x + \sum_{i, j} J_{ij} \sigma_i^z \sigma_j^z . \end{equation*}$$

D-Wave , — 2048 , Matlab, C/C++ Python . /, D-Wave . D-Wave .

B.

ProjectQ C++. Dell XPS 13 Developer Edition 64- Ubuntu 16.04 LTS 8 Intel Core i7-8550U 1,80 .

 # ------------------------------------------------------------------------------ # imports # ------------------------------------------------------------------------------ from projectq import MainEngine import projectq.ops as ops from projectq.backends import Simulator import sys import time # ------------------------------------------------------------------------------ # number of qubits and depth # ------------------------------------------------------------------------------ if len(sys.argv) > 1: n = int(sys.argv[1]) else: n = 16 if len(sys.argv) > 1: depth = int(sys.argv[2]) else: depth = 10 # ------------------------------------------------------------------------------ # engine and qubit register # ------------------------------------------------------------------------------ eng = MainEngine(backend=Simulator(gate_fusion=True), engine_list=[]) qbits = eng.allocate_qureg(n) # ------------------------------------------------------------------------------ # circuit # ------------------------------------------------------------------------------ # timing -- get the start time start = time.time() # random circuit for level in range(depth): for q in qbits: ops.H | q ops.SqrtX | q if q != qbits[0]: ops.CNOT | (q, qbits[0]) # measure for q in qbits: ops.Measure | q # flush the engine eng.flush() # timing -- get the end time runtime = time.time() - start # print out the runtime print(n, depth, runtime) 

, , 7. , QISKit — .

C. :

. , QDK , , . — , — — . . , , , — , .

, , . , QISKit.

pyQuil

 #!/usr/bin/env python3 # -*- coding: utf-8 -*- # ============================================================================== # teleport.py # # Teleportation circuit in pyQuil. # ============================================================================== # ------------------------------------------------------------------------------ # imports # ------------------------------------------------------------------------------ from pyquil.quil import Program from pyquil import api import pyquil.gates as gate # ------------------------------------------------------------------------------ # program and simulator # ------------------------------------------------------------------------------ qprog = Program() qvm = api.QVMConnection() # ------------------------------------------------------------------------------ # teleportation circuit # ------------------------------------------------------------------------------ # teleport |1> to qubit three qprog += gates.X(0) # main circuit qprog += [gates.H(1), gates.CNOT(1, 2), gates.CNOT(0, 1), gates.H(0), gates.MEASURE(0, 0), gates.MEASURE(1, 1)] # conditional operations qprog.if_then(0, gates.Z(2)) qprog.if_then(1, gates.X(2)) # measure qubit three qprog.measure(2, 2) # ------------------------------------------------------------------------------ # run the circuit and print the results # ------------------------------------------------------------------------------ print(qvm.run(qprog)) # optionally print the quil code print(qprog) 

QISKit

 #!/usr/bin/env python3 # -*- coding: utf-8 -*- # ============================================================================== # teleport.py # # Teleportation circuit in QISKit. # ============================================================================== # ------------------------------------------------------------------------------ # imports # ------------------------------------------------------------------------------ from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute # ------------------------------------------------------------------------------ # registers and quantum circuit # ------------------------------------------------------------------------------ qreg = QuantumRegister(3) creg = ClassicalRegister(3) qcircuit = QuantumCircuit(qreg, creg) # ------------------------------------------------------------------------------ # do the circuit # ------------------------------------------------------------------------------ # teleport |1> to qubit three qcircuit.x(qreg[0]) # main circuit qcircuit.h(qreg[0]) qcircuit.cx(qreg[1], qreg[2]) qcircuit.cx(qreg[0], qreg[1]) qcircuit.h(qreg[0]) qcircuit.measure(qreg[0], creg[0]) qcircuit.measure(qreg[1], creg[1]) # conditional operations qcircuit.z(qreg[2]).c_if(creg[0][0], 1) qcircuit.x(qreg[2]).c_if(creg[1][0], 1) # measure qubit three qcircuit.measure(qreg[2], creg[2]) # ------------------------------------------------------------------------------ # run the circuit and print the results # ------------------------------------------------------------------------------ result = execute(qcircuit, 'local_qasm_simulator').result() counts = result.get_counts() print(counts) # optionally print the qasm code print(qcircuit.qasm()) # optionally draw the circuit from qiskit.tools.visualization import circuit_drawer circuit_drawer(qcircuit) 

ProjectQ

 #!/usr/bin/env python3 # -*- coding: utf-8 -*- # ============================================================================== # teleport.py # # Teleportation circuit in ProjectQ. # ============================================================================== # ------------------------------------------------------------------------------ # imports # ------------------------------------------------------------------------------ from projectq import MainEngine from projectq.meta import Control import projectq.ops as ops # ------------------------------------------------------------------------------ # engine and qubit register # ------------------------------------------------------------------------------ # engine eng = MainEngine() # allocate qubit register qbits = eng.allocate_qureg(3) # ------------------------------------------------------------------------------ # teleportation circuit # ------------------------------------------------------------------------------ # teleport |1> to qubit three ops.X | qbits[0] # main circuit ops.H | qbits[1] ops.CNOT | (qbits[1], qbits[2]) ops.CNOT | (qbits[0], qbits[1]) ops.H | qbits[0] ops.Measure | (qbits[0], qbits[1]) # conditional operations with Control(eng, qbits[1]): ops.X | qbits[2] with Control(eng, qbits[1]): ops.Z | qbits[2] # measure qubit three ops.Measure | qbits[2] # ------------------------------------------------------------------------------ # run the circuit and print the results # ------------------------------------------------------------------------------ eng.flush() print("Measured:", int(qbits[2])) 

Quantum Developer Kit

 // ============================================================================= // teleport.qs // // Teleportation circuit in QDK. // ============================================================================= operation Teleport(msg : Qubit, there : Qubit) : () { body { using (register = Qubit[1]) { // get auxiliary qubit to prepare for teleportation let here = register[0]; // main circuit H(here); CNOT(here, there); CNOT(msg, here); H(msg); // conditional operations if (M(msg) == One) { Z(there); } if (M(here) == One) { X(there); } // reset the "here" qubit Reset(here); } } } operation TeleportClassicalMessage(message : Bool) : Bool { body { mutable measurement = false; using (register = Qubit[2]) { // two qubits let msg = register[0]; let there = register[1]; // encode message to send if (message) { X(msg); } // do the teleportation Teleport(msg, there); // check what message was sent if (M(there) == One) { set measurement = true; } // reset all qubits ResetAll(register); } return measurement; } }