A. pyQuil

pyQuil est une bibliothèque Python open source développée par Rigetti pour créer, analyser et exécuter des programmes quantiques. Il est construit sur la base du langage Quil - un langage ouvert d'instructions quantiques (ou simplement un langage quantique ), spécialement conçu pour les ordinateurs quantiques prometteurs les plus proches et basé sur un modèle de mémoire classique / quantique commun [24] (cela signifie que les qubits et bits classiques). pyQuil est l'une des bibliothèques principales développées dans Forest, qui est la plate-forme clé pour tous les logiciels Rigetti. Forest comprend également Grove et Reference QVM, qui seront décrits plus loin.

a. Configuration requise et installation

L'installation et l'utilisation de pyQuil nécessitent des versions Python 2 ou 3, bien que Python 3 soit fortement recommandé, car les futures fonctions de développement ne prendront en charge que Python 3. En outre, la distribution Python Anaconda est recommandée pour diverses dépendances de module Python, bien que cela ne soit pas nécessaire.

La façon la plus simple d'installer pyQuil est d'utiliser la commande du gestionnaire de packages Python. À l'invite de commande Linux Ubuntu, entrez

 pip install pyquil 

pour une installation réussie du logiciel. Alternativement, si Anaconda est installé, pyQuil peut être installé en tapant

 conda install −c rigetti pyquil 

sur la ligne de commande. Une autre alternative consiste à télécharger le code source à partir du référentiel git et à installer le logiciel. Pour ce faire, entrez les commandes suivantes:

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

Cette dernière méthode est recommandée pour tous les utilisateurs qui peuvent contribuer à pyQuil. Consultez le guide de dépôt GitHub pour plus d'informations.

b. Documentation et tutoriels

pyQuil a une excellente documentation publiée sur Internet, avec une introduction à l'informatique quantique, des instructions d'installation, des programmes de base et des opérations de porte, un simulateur connu sous le nom de machine virtuelle quantique (QVM), un véritable ordinateur quantique et un langage Quil avec un compilateur. En téléchargeant le code source pyQuil depuis GitHub, vous obtiendrez également un dossier avec des exemples dans les cahiers Jupyter, des exemples Python réguliers et un programme$$ $ inline $ \ textesf {run_quil.py} $ inline $ , qui peut exécuter des documents texte écrits en Quil à l'aide d'une machine virtuelle quantique. Enfin, mentionnez Grove , un ensemble d'algorithmes quantiques construits à l'aide de pyQuil et de l'environnement de la forêt Rigetti.

c. Syntaxe

La syntaxe pyQuil est très simple et pratique. Le principal élément d'enregistrement des circuits quantiques est le programme et peut être importé de $$$\ textesf {pyquil.quil}$ . Les opérations de porte peuvent être trouvées dans $$$\ textesf {pyquil.gates}$ . Module $$$\ textesf {api}$ vous permet d'exécuter des circuits quantiques dans une machine virtuelle. L'une des fonctionnalités intéressantes de pyQuil est que les registres qubit et les registres classiques n'ont pas à être définis a priori et peuvent être alloués dynamiquement en mémoire. Les Qubits dans le registre qubit sont désignés par des indices (0, 1, 2, ...) et de même pour les bits dans le registre classique. Ainsi, le circuit générateur aléatoire peut s'écrire comme suit:

 # 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. Code PyQuil pour un générateur de nombres aléatoires.

Les trois premières lignes importent le minimum nécessaire pour déclarer un schéma / programme quantique (ligne 2), pour effectuer des opérations de porte sur des qubits (ligne 3) [44] et pour exécuter le schéma (ligne 4). À la ligne 6, un programme quantique est créé, et aux lignes 7 à 8, une liste d'instructions lui est transmise: d'abord, agissez sur la porte Hadamard $$$H$ au-dessus du qubit à l'index 0, alors nous mesurons le même qubit en un bit classique sous l'index 0. La ligne 10 établit une connexion avec QVM, et à 11 le résultat de notre circuit est lancé et affiché. Ce programme imprime la sortie standard de pyQuil sous la forme d'une liste de listes d'entiers: dans notre cas - $$$\ textesf {[[[[0]]}}$ ou $$$\ textesf {[[[[1]]]}$ . En général, le nombre d'éléments dans une liste externe est le nombre de tests effectués. Les nombres entiers dans les listes internes sont les dimensions finales du registre classique. Puisque nous avons effectué un seul test (cela est indiqué comme argument dans $$$\ textesf {api.QVMConnection.run}$ , qui est défini sur l'unité par défaut), nous obtenons une seule liste interne. Puisque dans le registre classique, nous n'avions qu'un seul bit, nous n'obtenons qu'un seul entier.

d. Langue quantique

Quil est un langage d'instructions quantiques, ou tout simplement un langage quantique qui transmet des commandes à un ordinateur quantique. Ceci est similaire à l'assembleur sur les ordinateurs classiques. Le cœur de la syntaxe Quil est $$$\ textesf {index GATE}$ où $$$\ textesf {GATE}$ est une porte quantique qui s'applique aux qubits indexés $$$\ textesf {index}$ (0, 1, 2, ...). pyQuil a une fonction pour générer du code Quil à partir d'un programme donné. Par exemple, dans le générateur de nombres aléatoires quantiques susmentionné, nous pourrions ajouter la ligne:

 print(qprog) 

à la fin pour obtenir le code du diagramme Quil, qui est illustré ci-dessous:

 H 0 MEASURE 0 [0] 

Listing 3. Code Quil pour un générateur de nombres aléatoires.

Peut-être que si quelqu'un commence à comprendre Quil, écrivez des circuits quantiques dans un éditeur de texte dans Quil, puis exécutez le circuit sur QVM à l'aide du programme$$ $ inline $ \ textesf {run_quil.py} $ inline $ . Vous pouvez également modifier$$ $ inline $ \ textesf {run_quil.py} $ inline $ pour exécuter le circuit sur QPU. Notez que le compilateur pyQuil (également appelé compilateur Quil dans la documentation) convertit le circuit donné en code Quil qu'un véritable ordinateur quantique peut comprendre. Nous en discuterons plus en détail dans la section III C.

f. Matériel quantique

Rigetti a un processeur quantique qui peut être utilisé par ceux qui demandent l'accès. Pour demander l'accès, vous devez visiter le site Web de Rigetti et fournir le nom complet, l'adresse e-mail, le nom de l'organisation et une description de la raison de l'accès au QPU. Une fois cela fait, un représentant de l'entreprise vous contactera par e-mail pour planifier un moment pour donner à l'utilisateur l'accès au QPU. L'avantage de ce processus de planification, contrairement au système de mise en file d'attente QISKit, qui sera discuté plus tard, est que de nombreuses tâches peuvent être effectuées dans un intervalle de temps distribué avec des temps d'exécution déterministes, ce qui est essentiel pour les algorithmes variationnels et hybrides. Ces types d'algorithmes envoient des données entre les ordinateurs classiques et quantiques - la nécessité d'attendre en ligne rend ce processus beaucoup plus long. L'inconvénient (éventuellement) est que les tâches ne peuvent être effectuées à aucun moment lorsque le QPU est disponible et qu'il est nécessaire d'indiquer et de convenir d'un moment précis.

Selon l'expérience de l'auteur, les employés sont prêts à aider et le processus est généralement couronné de succès. Le périphérique réel, dont la topologie est illustrée à la figure 2, se compose de 8 qubits avec la connectivité du voisin le plus proche. Nous examinerons cet ordinateur plus en détail dans la section III B.

g. Simulateur

La machine virtuelle quantique (QVM) est le principal utilitaire utilisé pour exécuter les circuits quantiques. Ce programme, écrit pour fonctionner sur un processeur classique, reçoit le code Quil et simule le développement d'un processus sur un véritable ordinateur quantique. Pour vous connecter à QVM, vous devez enregistrer gratuitement une clé API sur https://www.rigetti.com/forest avec un nom et une adresse e-mail. Ensuite, vous recevrez un e-mail contenant la clé API et l'ID utilisateur qui doivent être configurés au démarrage:

 pyquil−config−setup 

sur la ligne de commande (après l'installation de pyQuil, bien sûr). Ensuite, il vous sera demandé de saisir les clés de l'e-mail.

Selon la documentation, la plupart des clés d'API permettent d'accéder à des machines virtuelles Java jusqu'à 30 qubits, et vous pouvez demander l'accès à plus de qubits. La clé API de l'auteur donne accès à 26 qubits (aucune mise à jour n'a été demandée).

De plus, la bibliothèque Forest contient un simulateur local écrit en Python et open source, appelé Reference QVM . Il n'est pas aussi productif que QVM, mais les utilisateurs peuvent exécuter des circuits avec un nombre de qubits limité par la quantité de mémoire sur les machines locales. En règle générale, les circuits avec moins de 20 qubits peuvent être exécutés sur une large gamme d'équipements. La référence QVM doit être installée séparément, ce qui peut être fait avec $$$\ textesf {pip}$ :

 pip install referenceqvm 

Pour utiliser Reference QVM au lieu de QVM, importez simplement $$$\ textesf {api}$ de $$$\ textesf {referenceqvm}$ au lieu de pyQuil:

 import referenceapi.api as api 

B. QISKit

Le Quantum Information Software Kit, ou QISKit, est un kit de développement logiciel (SDK) open source pour travailler avec le langage quantique OpenQASM et les processeurs quantiques dans la plate-forme IBM Q. Il est disponible pour les langages Python, JavaScript et Swift, mais ici nous ne discutons que Version Python.

a. Configuration requise et installation

QISKit est disponible sur MacOS, Windows et Linux. L'installation de QISKit nécessite Python 3.5+. Les composants Jupyter Notebooks for tutorials et la distribution Python Anaconda 3, qui contient toutes les dépendances nécessaires, sont des composants utiles mais non obligatoires supplémentaires.

La façon la plus simple d'installer QISKit est d'utiliser le gestionnaire de packages pip pour Python. À l'invite de commande, pour installer le logiciel, entrez:

 pip install qiskit 

Veuillez noter que $$$\ textesf {pip}$ traite automatiquement toutes les dépendances et installe toujours la dernière version. Les utilisateurs qui pourraient être intéressés à contribuer à QISKit peuvent installer le code source en entrant ce qui suit à l'invite de commande, on suppose que git est installé:

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

Pour plus d'informations sur les dépôts, consultez la documentation en ligne du guide des dépôts sur GitHub.

b. Documentation et matériel de formation

La documentation QISKit est disponible sur Internet à l' adresse https://qiskit.org/documentation/ . Il contient des instructions d'installation et de configuration, des exemples de programmes et de connexion à de véritables appareils quantiques, l'organisation du projet, une revue QISKit et une documentation pour les développeurs. Des informations de base sur l'informatique quantique peuvent également être trouvées pour les utilisateurs qui sont nouveaux dans le domaine. Une très bonne ressource est un lien vers le SDK, où les utilisateurs peuvent trouver des informations sur la documentation du code source.

QISKit contient également un grand nombre de didacticiels dans un référentiel GitHub séparé (similaire à pyQuil et Grove). Il s'agit notamment des États intriqués; des algorithmes standard tels que Deutsch Jozh, l'algorithme de Grover, l'estimation de phase et la transformée de Fourier quantique; également des algorithmes plus complexes, tels que la résolution d'un problème de valeur propre variationnelle quantique et l'application aux hamiltoniens fermions; et même des jeux amusants, comme la «bataille navale» quantique. De plus, la bibliothèque ACQUA (Algorithms and Circuits for QUantum Applications) contient des algorithmes multidisciplinaires pour la chimie et l'intelligence artificielle avec de nombreux exemples.

Il existe également une documentation très détaillée pour chacun des quatre backends quantiques contenant des informations sur la connectivité, le temps de cohérence et le temps d'utilisation de la porte. Enfin, mentionnez le site Web d' expérience IBM Q et les guides d'utilisation. Le site Web contient une interface graphique pour un circuit quantique dans laquelle les utilisateurs peuvent faire glisser des portes sur un circuit, ce qui est utile pour explorer les circuits quantiques. Les guides de l'utilisateur contiennent plus d'instructions sur l'informatique quantique et le langage QISKit.

c. Syntaxe

La syntaxe QISKit peut être consultée dans l'exemple de programme suivant. Ici, contrairement à pyQuil, vous devez faire une distinction explicite entre les registres quantiques et classiques. Voici un programme pour le schéma de nombres aléatoires 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()) 

Listing 4. Code QISKit pour un générateur de nombres aléatoires.

La ligne 2 importe des outils pour créer des registres quantiques et classiques, un circuit quantique et des fonctions pour exécuter ce circuit. Ensuite, nous créons un registre quantique avec un qubit (ligne 4), un registre classique avec un bit (ligne 5) et un circuit quantique avec ces deux registres (ligne 6). Maintenant que le circuit est créé, nous commençons à donner des instructions: à la ligne 8, nous appliquons la porte de Hadamard au qubit zéro dans notre registre quantique (qui est le seul qubit du registre quantique); à la ligne 9, nous mesurons ce qubit en un bit classique indexé par zéro dans notre registre classique (qui est le seul dans le registre classique) [45]. Maintenant que le circuit quantique est construit, exécutez-le sur la ligne 11 et imprimez le résultat sur la ligne 12. Au moyen de la sortie$$ $ inline $ \ textesf {result.get_counts ()} $ inline $ nous obtenons les «calculs» du circuit, c'est-à-dire le dictionnaire des données de sortie et combien de fois chaque résultat a été reçu. Dans notre cas, les seules sorties possibles sont 0 ou 1, et un exemple de la sortie du programme ci-dessus est $$$\ textesf {{'0': 532, '1': 492}}$ , ce qui indique que nous avons obtenu 532 instances de 0 et 492 instances de 1. (Par défaut, le nombre de cycles pour démarrer le circuit appelé $$$\ textesf {coups}$ dans QISKit, est 1024.)

d. Langue quantique

OpenQASM (le langage d'assemblage quantique ouvert [25], que nous pouvons simplement appeler QASM) est un langage quantique qui fournit des instructions pour de vrais dispositifs quantiques similaires à l'assembleur sur les ordinateurs classiques. La base de la syntaxe QASM est $$$\ textesf {gate qubit}$ où $$$\ textesf {gate}$ définit le fonctionnement de la porte quantique, et $$$\ textesf {qubit}$ - qubit. QISKit a une fonction pour générer du code QASM à partir d'un schéma. Dans le schéma de nombres aléatoires ci-dessus, nous pourrions ajouter une ligne.

 print(qcircuit.qasm()) 

à la fin pour obtenir le code QASM pour le circuit illustré ci-dessous:

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

Listing 5. Code OpenQASM pour un générateur de nombres aléatoires.

Les deux premières lignes sont incluses dans chaque fichier QASM. La ligne 3 (4) crée un registre quantique (classique) et les lignes 5 et 6 donnent des instructions pour le circuit. Dans OpenQASM, vous pouvez écrire de petits circuits comme ceux-ci, mais pour les circuits plus grands, il est préférable d'utiliser des outils dans QISKit pour une programmation gratuite et efficace des ordinateurs quantiques.

e. Matériel quantique

Il existe une énorme quantité de documentation pour les backends quantiques pris en charge par QISKit. Ces périphériques incluent IBMQX2 (5 qubits), IBMQX4 (5 qubits), IBMQX5 (16 qubits) et QS1_1 (20 qubits, disponible uniquement pour les membres d'IBM Q Network). La documentation pour tout le monde est disponible sur GitHub. Nous examinerons de plus près IBMQX5 dans la section III B, dont la topologie est illustrée à la figure 3.

f. Simulateur

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