A. pyQuil

pyQuil is an open source Python library developed by Rigetti for creating, analyzing and executing quantum programs. It is built on the basis of the Quil language — an open language of quantum instructions (or just a quantum language ), specially developed for the nearest promising quantum computers and based on a common model of classical / quantum memory [24] (this means that both quits and classic bits). pyQuil is one of the main libraries developed by Forest, which is a key platform for all Rigetti software. Forest also includes Grove and Reference QVM, which will be described later.

a. Requirements and installation

To install and use pyQuil, Python 2 or 3 versions are required, although Python 3 is strongly recommended, as future functions will only support Python 3. In addition, the Anaconda Python distribution is recommended for various Python module dependencies, although this is not required.

The easiest way to install pyQuil is to use the Python package manager command. Linux Ubuntu command line is entered

 pip install pyquil 

for successful software installation. Alternatively, if Anaconda is installed, you can install pyQuil by typing

 conda install −c rigetti pyquil 

on the command line. Another alternative is to download the source code from the git repository and install the software. To do this, enter the following commands:

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

This latter method is recommended for all users who can contribute to pyQuil. For more information, see the GitHub Contributions Guide.

b. Documentation and tutorials

pyQuil has excellent documentation hosted on the Internet, with an introduction to quantum computing, installation instructions, basic programs and gate operations, a simulator known as a quantum virtual machine (QVM), a real quantum computer and Quil with a compiler. By downloading the pyQuil source code from GitHub, you will also get an example folder in Jupyter notebooks, common Python examples and a program.$$ $ inline $ \ textsf {run_quil.py} $ inline $ that can run text documents written in Quil using a quantum virtual machine. Finally, mention Grove , a set of quantum algorithms built using pyQuil and the Rigetti Forest environment.

c. Syntax

The pyQuil syntax is very simple and practical. The main element for writing quantum circuits is a program and can be imported from $$$\ textsf {pyquil.quil}$ . Gate operations can be found in $$$\ textsf {pyquil.gates}$ . Module $$$\ textsf {api}$ allows you to run quantum schemes on a virtual machine. One of the nice features of pyQuil is that qubit registers and classical registers do not have to be defined a priori and can be dynamically allocated in memory. Qbits in the qubit register are referred to by indices (0, 1, 2, ...) and similarly for bits in the classical register. Thus, the random generator circuit can be written as follows:

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

Listing 2. PyQuil code for a random number generator.

The first three lines import the minimum required to declare a quantum scheme / program (line 2), to perform gate operations on qubits (line 3) [44], and to execute the scheme (line 4). In line 6, a quantum program is created, and in lines 7-8, a list of instructions is transmitted to it: first, let us act with Hadamard gate $$$H$ above the qubit under the index 0, then we measure the same qubit into the classic bit under the index 0. In line 10 a connection with QVM is established, and at 11 the result of our circuit is launched and output. This program prints the standard output of pyQuil as a list of lists of integers: in our case $$$\ textsf {[[0]]}$ or $$$\ textsf {[[1]]}$ . In general, the number of items in an external list is the number of tests performed. Integer numbers in internal lists are the final dimensions in a classic register. Since we performed only one trial (this is indicated as an argument in $$$\ textsf {api.QVMConnection.run}$ , which by default is set to one), we get only one internal list. Since in the classical register we had only one bit, we get only one integer.

d. Quantum language

Quil is a quantum instruction language or simply a quantum language that transmits commands to a quantum computer. This is similar to assembler on classic computers. The core of Quil syntax is $$$\ textsf {GATE index}$ where $$$\ textsf {GATE}$ is a quantum gate that applies to qubit indexed $$$\ textsf {index}$ (0, 1, 2, ...). pyQuil has a function to generate Quil code from a given program. For example, in the aforementioned quantum random number generator, we could add the line:

 print(qprog) 

at the end to get the Quil-code, which is shown below:

 H 0 MEASURE 0 [0] 

Listing 3. Quil code for a random number generator.

Perhaps, if someone begins to understand Quil, write quantum schemes in a text editor in the Quil language, and then execute a QVM scheme using the program$$ $ inline $ \ textsf {run_quil.py} $ inline $ . You can also modify$$ $ inline $ \ textsf {run_quil.py} $ inline $ to run the circuit on QPU. Note that the pyQuil compiler (also referred to as the Quil compiler in the documentation) converts the given scheme into Quil code that a real quantum computer can understand. We will discuss this in more detail in section III C.

f. Quantum hardware

Rigetti has a quantum processor that can be used by those requesting access. To request access, you must visit the Rigetti website and provide the full name, email address, organization name, and a description of the basis for accessing the QPU. Once this is done, a company representative will email to schedule the time to give the user access to the QPU. The advantage of this scheduling process, unlike the QISKit queuing system, which will be discussed further, is that many tasks can be performed in a distributed time interval with deterministic execution time, which is key to variational and hybrid algorithms. These types of algorithms send data in the opposite and forward direction between classical and quantum computers - the need to wait in line makes this process much longer. The disadvantage (perhaps) is that the tasks cannot be executed at any time when QPU is available and you need to specify and agree on a specific time.

According to the author’s experience, staff are ready to help, and the process is usually successful. The current device, the topology of which is shown in Figure 2, consists of an 8 qubit with the nearest neighbor connected. We will look at this computer in more detail in section III B.

g. Simulator

A quantum virtual machine (QVM) is the main utility used to execute quantum circuits. This program, written to run on a classical processor, receives Quil code and simulates the development of a process on a real quantum computer. To connect to QVM, you need to register an API key for free at https://www.rigetti.com/forest , specifying your name and email address. Then you will receive an email containing the API key and the user ID that must be configured at startup:

 pyquil−config−setup 

on the command line (after installing pyQuil, of course). Then you will be prompted to enter the keys from the email.

According to the documentation, most API keys provide access to QVM for up to 30 qubits, and you can request access to more qubits. The author's API key gives access to 26 qubits (no updates were requested).

In addition, the Forest library contains a local simulator, written in Python and open source, referred to as Reference QVM . It is not as productive as QVM, but users can run circuits with the number of qubits limited by the amount of memory on local machines. As a rule, it is possible to run circuits with a number of qubit less than 20 on a wide range of equipment. Reference QVM must be installed separately, which can be done using $$$\ textsf {pip}$ :

 pip install referenceqvm 

To use Reference QVM instead of QVM, simply import $$$\ textsf {api}$ of $$$\ textsf {referenceqvm}$ instead of pyQuil:

 import referenceapi.api as api 

B. QISKit

The Quantum Information Software Kit, or QISKit, is an open source software development kit (SDK) for working with the OpenQASM quantum language and quantum processors in the IBM Q platform. It is available for Python, JavaScript, and Swift, but here we only discuss version of python.

a. Requirements and installation

QISKit is available on MacOS, Windows and Linux. Installing QISKit requires Python 3.5+. Additional useful, but not mandatory components are Jupyter Notebooks for tutorials and the Python Anaconda 3 distribution, which contains all the necessary dependencies.

The easiest way to install QISKit is to use the pip package manager for Python. At the command prompt, to install the software, we enter:

 pip install qiskit 

note that $$$\ textsf {pip}$ automatically handles all dependencies and will always install the latest version. Users who may be interested in contributing to QISKit can install the source code by typing the following in the command line, assuming git is installed:

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

For information on contributions, see the online documentation for the contributions guide on GitHub.

b. Documentation and training materials

The QISKit documentation can be found online at https://qiskit.org/documentation/ . It contains instructions for installing and configuring, examples of programs and connecting to real quantum devices, project organization, a QISKit overview and developer documentation. Basic information about quantum computing can also be found for users who are new to this field. A very good resource is a link to the SDK where users can find information about the source code documentation.

QISKit also contains a large number of tutorials in a separate GitHub repository (similar to pyQuil and Grove). These include entangled states; standard algorithms, such as the Deutsch-Yozha, Grover’s algorithm, phase estimation, and the quantum Fourier transform; also more complex algorithms, such as solving a quantum variational eigenvalue problem and applying to fermion Hamiltonians; and even some fun games like quantum sea battle. In addition, the ACQUA library (Algorithms for Circuits for QUantum Applications) contains multi-disciplinary algorithms for chemistry and artificial intelligence with numerous examples.

There is also very detailed documentation for each of the four quantum backends containing information about connectivity, coherence time, and gate time. Finally, mention the IBM Q experience website and user guides. The website contains a graphical interface for the quantum scheme, in which users can drag gates onto the scheme, which is useful for studying quantum schemes. User manuals contain more instructions on quantum computing and the QISKit language.

c. Syntax

The syntax QISKit can be viewed in the following sample program. Here, unlike pyQuil, you need to explicitly allocate quantum and classical registers. The following shows the program for the random number scheme in 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()) 

Listing 4. QISKit code for a random number generator.

Line 2 imports the tools for creating quantum and classical registers, a quantum circuit, and a function to execute this circuit. Then we create a quantum register with one qubit (line 4), a classical register with one bit (line 5) and a quantum circuit with both of these registers (line 6). Now that the scheme has been created, we begin to give instructions: in line 8, we apply the Hadamard gate to the zero qubit in our quantum register (which is the only qubit in the quantum register); in line 9 we measure this qubit in the classical bit, indexed by zero in our classical register (which is the only one in the classical register) [45]. Now that the quantum scheme has been built, we will execute it in line 11 and print the result in line 12. Through the output$$ $ inline $ \ textsf {result.get_counts ()} $ inline $ we get “calculations” of the scheme, that is, a dictionary of output data and how many times each result was obtained. For our case, the only possible outputs are 0 or 1, and an example of the output of the above program is $$$\ textsf {{'0': 532, '1': 492}}$ , which indicates that we received 532 instances of 0 and 492 instances of 1. (By default, the number of cycles to run the circuit, called $$$\ textsf {shots}$ in QISKit, it is 1024.)

d. Quantum language

OpenQASM (open language quantum assembler [25], which we can simply call QASM) is a quantum language that provides instructions for real quantum devices similar to assembler on classical computers. The core of the QASM syntax is $$$\ textsf {gate qubit}$ where $$$\ textsf {gate}$ sets the quantum valve operation, and $$$\ textsf {qubit}$ - qubit. QISKit has a function for generating QASM code from a schema. In the example of the random number scheme above, we could add a line.

 print(qcircuit.qasm()) 

at the end to get the QASM code for the circuit shown below:

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

Listing 5. OpenQASM code for a random number generator.

The first two lines are included in each QASM file. Line 3 (4) creates a quantum (classical) register, and lines 5 and 6 give instructions for the circuit. In OpenQASM, you can write small schemes like these, but for larger schemes it is better to use tools in QISKit for free and effective programming of quantum computers.

e. Quantum hardware

There is a huge amount of documentation for quantum backends supported by QISKit. These devices include IBMQX2 (5 qubits), IBMQX4 (5 qubits), IBMQX5 (16 qubits) and QS1_1 (20 qubits, accessible only by members of the IBM Q Network). Documentation for each is available on GitHub. We will look at IBMQX5 in detail in section III B, the topology of which is shown in Figure 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. Syntax

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. Syntax

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.

Bibliography

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; } }