A. pyQuil

pyQuil es una biblioteca Python de código abierto desarrollada por Rigetti para crear, analizar y ejecutar programas cuánticos. Está construido sobre la base del lenguaje Quil, un lenguaje abierto de instrucciones cuánticas (o simplemente un lenguaje cuántico ), especialmente diseñado para las computadoras cuánticas prometedoras más cercanas y basado en un modelo común de memoria clásica / cuántica [24] (esto significa que tanto qubits como bits clásicos). pyQuil es una de las bibliotecas principales desarrolladas en Forest, que es la plataforma clave para todo el software Rigetti. Forest también incluye Grove y Reference QVM, que se describirá más adelante.

a. Requisitos e instalación

La instalación y el uso de pyQuil requiere versiones de Python 2 o 3, aunque Python 3 es muy recomendable, ya que las funciones de desarrollo futuras solo admitirán Python 3. Además, la distribución Anaconda de Python se recomienda para varias dependencias del módulo Python, aunque esto no es necesario.

La forma más fácil de instalar pyQuil es usar el comando del administrador de paquetes Python. En el símbolo del sistema Linux Ubuntu, ingrese

 pip install pyquil 

para una instalación exitosa del software. Alternativamente, si Anaconda está instalado, pyQuil puede instalarse escribiendo

 conda install −c rigetti pyquil 

en la línea de comando. Otra alternativa es descargar el código fuente del repositorio de git e instalar el software. Para hacer esto, ingrese los siguientes comandos:

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

Este último método se recomienda para todos los usuarios que pueden contribuir a pyQuil. Consulte la guía de depósitos de GitHub para obtener más información.

b. Documentación y Tutoriales

pyQuil tiene una excelente documentación publicada en Internet, con una introducción a la computación cuántica, instrucciones de instalación, programas básicos y operaciones de puertas, un simulador conocido como máquina virtual cuántica (QVM), una computadora cuántica real y un lenguaje Quil con un compilador. Al descargar el código fuente pyQuil de GitHub, también obtendrá una carpeta con ejemplos en cuadernos Jupyter, ejemplos regulares de Python y un programa$$ $ en línea $ \ textf {run_quil.py} $ en línea $ , que puede ejecutar documentos de texto escritos en Quil utilizando una máquina virtual cuántica. Finalmente, mencione Grove , un conjunto de algoritmos cuánticos creados con pyQuil y el entorno del bosque Rigetti.

c. Sintaxis

La sintaxis de pyQuil es muy simple y práctica. El elemento principal para grabar circuitos cuánticos es el programa y se puede importar desde $$$\ textf {pyquil.quil}$ . Las operaciones de puerta se pueden encontrar en $$$\ textf {pyquil.gates}$ . Modulo $$$\ textf {api}$ le permite ejecutar circuitos cuánticos en una máquina virtual. Una de las buenas características de pyQuil es que los registros qubit y los registros clásicos no tienen que definirse a priori y pueden asignarse dinámicamente en la memoria. Las cúbitas en el registro de qubits se denominan por índices (0, 1, 2, ...) y de manera similar para bits en el registro clásico. Por lo tanto, el circuito generador aleatorio se puede escribir de la siguiente manera:

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

Listado 2. Código PyQuil para un generador de números aleatorios.

Las primeras tres líneas importan el mínimo necesario para declarar un esquema / programa cuántico (línea 2), realizar operaciones de compuerta en qubits (línea 3) [44] y ejecutar el esquema (línea 4). En la línea 6, se crea un programa cuántico, y en las líneas 7-8, se le transmite una lista de instrucciones: primero, actúe en la puerta Hadamard $$$H$ arriba del qubit en el índice 0, luego medimos el mismo qubit en un bit clásico debajo del índice 0. La línea 10 establece una conexión con QVM, y en 11 se inicia y muestra el resultado de nuestro circuito. Este programa imprime la salida estándar de pyQuil como una lista de listas de enteros: en nuestro caso, $$$\ textf {[[[0]]}$ o $$$\ textf {[[[1]]}$ . En general, el número de elementos en una lista externa es el número de pruebas realizadas. Los números enteros en las listas internas son las dimensiones finales en el registro clásico. Como solo realizamos una prueba (esto se indica como un argumento en $$$\ textf {api.QVMConnection.run}$ , que se establece en la unidad de forma predeterminada), solo obtenemos una lista interna. Como en el registro clásico solo teníamos un bit, obtenemos solo un entero.

d. Lenguaje cuántico

Quil es un lenguaje de instrucciones cuánticas, o simplemente un lenguaje cuántico que transmite comandos a una computadora cuántica. Esto es similar al ensamblador en computadoras clásicas. El núcleo de la sintaxis de Quil es $$$\ textf {índice GATE}$ donde $$$\ textf {GATE}$ es una puerta cuántica que se aplica a qubits indexados $$$\ textf {index}$ (0, 1, 2, ...). pyQuil tiene una función para generar código Quil a partir de un programa dado. Por ejemplo, en el generador de números aleatorios cuánticos mencionado anteriormente, podríamos agregar la línea:

 print(qprog) 

al final para obtener el código del diagrama de Quil, que se muestra a continuación:

 H 0 MEASURE 0 [0] 

Listado 3. Código quil para un generador de números aleatorios.

Quizás si alguien comienza a entender Quil, escriba circuitos cuánticos en un editor de texto en Quil, y luego ejecute el circuito en QVM usando el programa$$ $ en línea $ \ textf {run_quil.py} $ en línea $ . También puedes modificar$$ $ en línea $ \ textf {run_quil.py} $ en línea $ para ejecutar el circuito en QPU. Tenga en cuenta que el compilador pyQuil (también llamado compilador Quil en la documentación) convierte el circuito dado en un código Quil que una computadora cuántica real puede entender. Discutiremos esto con más detalle en la sección III C.

f. Hardware cuántico

Rigetti tiene un procesador cuántico que pueden usar aquellos que solicitan acceso. Para solicitar acceso, debe visitar el sitio web de Rigetti y proporcionar el nombre completo, la dirección de correo electrónico, el nombre de la organización y una descripción de la razón para acceder a la QPU. Una vez hecho esto, un representante de la empresa se comunicará con usted por correo electrónico para programar una hora para dar acceso al usuario a la QPU. La ventaja de este proceso de programación, en contraste con el sistema de colas QISKit, que se discutirá más adelante, es que muchas tareas se pueden realizar en un intervalo de tiempo distribuido con tiempos de ejecución deterministas, que es clave para algoritmos híbridos y variacionales. Estos tipos de algoritmos envían datos de un lado a otro entre computadoras clásicas y cuánticas; la necesidad de esperar en línea hace que este proceso sea mucho más largo. La desventaja (posiblemente) es que las tareas no se pueden realizar en cualquier momento cuando el QPU está disponible y es necesario indicar y acordar un momento específico.

Según la experiencia del autor, los empleados están listos para ayudar, y el proceso suele ser exitoso. El dispositivo real, cuya topología se muestra en la Figura 2, consta de 8 qubits con la conectividad vecina más cercana. Veremos esta computadora con más detalle en la Sección III B.

g. Simulador

Quantum Virtual Machine (QVM) es la principal utilidad utilizada para ejecutar circuitos cuánticos. Este programa, escrito para ejecutarse en un procesador clásico, recibe el código Quil y simula el desarrollo de un proceso en una computadora cuántica real. Para conectarse a QVM, debe registrar una clave API de forma gratuita en https://www.rigetti.com/forest con un nombre y una dirección de correo electrónico. Luego, recibirá un correo electrónico con la clave API y la ID de usuario que debe configurarse al inicio:

 pyquil−config−setup 

en la línea de comando (después de instalar pyQuil, por supuesto). Luego se le pedirá que ingrese las claves del correo electrónico.

De acuerdo con la documentación, la mayoría de las claves API proporcionan acceso a QVM de hasta 30 qubits, y puede solicitar acceso a más qubits. La clave API del autor da acceso a 26 qubits (no se solicitaron actualizaciones).

Además, la biblioteca Forest contiene un simulador local escrito en Python y de código abierto, denominado QVM de referencia . No es tan productivo como QVM, pero los usuarios pueden ejecutar circuitos con el número de qubits limitado por la cantidad de memoria en las máquinas locales. Por lo general, los circuitos con menos de 20 qubits se pueden ejecutar en una amplia gama de equipos. La referencia QVM debe instalarse por separado, lo que se puede hacer con $$$\ textf {pip}$ :

 pip install referenceqvm 

Para usar QVM de referencia en lugar de QVM, solo importe $$$\ textf {api}$ de $$$\ textf {referenceqvm}$ en lugar de pyQuil:

 import referenceapi.api as api 

B. QISKit

El Quantum Information Software Kit, o QISKit, es un kit de desarrollo de software de código abierto (SDK) para trabajar con el lenguaje cuántico OpenQASM y los procesadores cuánticos en la plataforma IBM Q. Está disponible para los lenguajes Python, JavaScript y Swift, pero aquí solo discutimos Versión de Python

a. Requisitos e instalación

QISKit está disponible en MacOS, Windows y Linux. La instalación de QISKit requiere Python 3.5+. Componentes adicionales útiles, pero no necesarios, son los Cuadernos Jupyter para tutoriales y la distribución Python Anaconda 3, que contiene todas las dependencias necesarias.

La forma más fácil de instalar QISKit es usar el administrador de paquetes pip para Python. En el símbolo del sistema, para instalar el software, ingrese:

 pip install qiskit 

Tenga en cuenta que $$$\ textf {pip}$ procesa automáticamente todas las dependencias y siempre instalará la última versión. Los usuarios que puedan estar interesados ​​en contribuir a QISKit pueden instalar el código fuente ingresando lo siguiente en el símbolo del sistema, se supone que git está instalado:

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

Para obtener información sobre depósitos, consulte la documentación en línea de la guía de depósitos en GitHub.

b. Documentación y materiales de capacitación.

La documentación de QISKit se puede encontrar en Internet en https://qiskit.org/documentation/ . Contiene instrucciones de instalación y configuración, programas de muestra y conexión a dispositivos cuánticos reales, organización de proyectos, una revisión de QISKit y documentación para desarrolladores. También se puede encontrar información básica sobre computación cuántica para usuarios que son nuevos en el campo. Un recurso muy bueno es un enlace al SDK, donde los usuarios pueden encontrar información sobre la documentación del código fuente.

QISKit también contiene una gran cantidad de tutoriales en un repositorio GitHub separado (similar a pyQuil y Grove). Estos incluyen estados enredados; algoritmos estándar como Deutsch Jozh, algoritmo de Grover, estimación de fase y transformación cuántica de Fourier; también algoritmos más complejos, como la resolución de un problema de valor propio variacional cuántico y la aplicación a fermiones hamiltonianos; e incluso algunos juegos divertidos, como la "batalla naval" cuántica. Además, la biblioteca ACQUA (Algorithms and Circuits for QUantum Applications) contiene algoritmos multidisciplinarios para química e inteligencia artificial con numerosos ejemplos.

También hay documentación muy detallada para cada uno de los cuatro backends cuánticos que contiene información sobre conectividad, tiempo de coherencia y tiempo de uso de puerta. Finalmente, mencione el sitio web y las guías de usuario de la experiencia IBM Q. El sitio web contiene una interfaz gráfica para un circuito cuántico en el que los usuarios pueden arrastrar puertas a un circuito, lo cual es útil para explorar los circuitos cuánticos. Las guías del usuario contienen más instrucciones sobre computación cuántica y el lenguaje QISKit.

c. Sintaxis

La sintaxis de QISKit se puede ver en el siguiente programa de muestra. Aquí, a diferencia de pyQuil, debe distinguir explícitamente entre registros cuánticos y clásicos. A continuación se muestra un programa para el esquema de números aleatorios de 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()) 

Listado 4. Código QISKit para un generador de números aleatorios.

La línea 2 importa herramientas para crear registros cuánticos y clásicos, un circuito cuántico y funciones para ejecutar este circuito. Luego creamos un registro cuántico con un qubit (línea 4), un registro clásico con un bit (línea 5) y un circuito cuántico con ambos registros (línea 6). Ahora que el circuito está creado, comenzamos a dar instrucciones: en la línea 8 aplicamos la puerta Hadamard al qubit cero en nuestro registro cuántico (que es el único qubit en el registro cuántico); en la línea 9, medimos este qubit en un bit clásico indexado por cero en nuestro registro clásico (que es el único en el registro clásico) [45]. Ahora que el circuito cuántico está construido, ejecútelo en la línea 11 e imprima el resultado en la línea 12. Por medio de la salida$$ $ en línea $ \ textf {result.get_counts ()} $ en línea $ obtenemos los "cálculos" del circuito, es decir, el diccionario de datos de salida y cuántas veces se recibió cada resultado. Para nuestro caso, las únicas salidas posibles son 0 o 1, y un ejemplo de la salida del programa anterior es $$$\ textf {{'' 0 ': 532,' 1 ': 492}}$ , lo que indica que obtuvimos 532 instancias de 0 y 492 instancias de 1. (Por defecto, el número de ciclos para iniciar el circuito se llama $$$\ textf {disparos}$ en QISKit, es 1024.)

d. Lenguaje cuántico

OpenQASM (el lenguaje de ensamblador cuántico abierto [25], que simplemente podemos llamar QASM) es un lenguaje cuántico que proporciona instrucciones para dispositivos cuánticos reales similares al ensamblador en computadoras clásicas. La base de la sintaxis QASM es $$$\ textf {puerta qubit}$ donde $$$\ textf {puerta}$ establece el funcionamiento de la puerta cuántica, y $$$\ textf {qubit}$ - qubit. QISKit tiene una función para generar código QASM a partir de un esquema. En el esquema de números aleatorios anterior, podríamos agregar una línea.

 print(qcircuit.qasm()) 

al final para obtener el código QASM para el circuito que se muestra a continuación:

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

Listado 5. Código OpenQASM para un generador de números aleatorios.

Las primeras dos líneas se incluyen en cada archivo QASM. La línea 3 (4) crea un registro cuántico (clásico), y las líneas 5 y 6 dan instrucciones para el circuito. En OpenQASM, puede escribir circuitos pequeños como estos, pero para circuitos más grandes, es mejor usar herramientas en QISKit para la programación gratuita y eficiente de computadoras cuánticas.

e. Hardware cuántico

Existe una gran cantidad de documentación para backends cuánticos compatibles con QISKit. Estos dispositivos incluyen IBMQX2 (5 qubits), IBMQX4 (5 qubits), IBMQX5 (16 qubits) y QS1_1 (20 qubits, disponibles solo para miembros de IBM Q Network). La documentación para todos está disponible en GitHub. Echaremos un vistazo más de cerca a IBMQX5 en la Sección III B, cuya topología se muestra en la Figura 3.

f. Simulador

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