A. pyQuil

pyQuil é uma biblioteca Python de código aberto desenvolvida por Rigetti para criar, analisar e executar programas quânticos. É construído com base na linguagem Quil - uma linguagem aberta de instruções quânticas (ou simplesmente uma linguagem quântica ), especialmente projetada para os computadores quânticos mais promissores e com base em um modelo de memória quântica clássica / comum [24] (isso significa que ambos, qubits e bits clássicos). O pyQuil é uma das principais bibliotecas desenvolvidas na Forest, que é a principal plataforma para todos os softwares Rigetti. Forest também inclui Grove e QVM de referência, que serão descritos mais adiante.

a. Requisitos e instalação

A instalação e o uso do pyQuil requerem versões do Python 2 ou 3, embora o Python 3 seja altamente recomendado, pois as futuras funções de desenvolvimento suportam apenas o Python 3. Além disso, a distribuição do Python Anaconda é recomendada para várias dependências do módulo Python, embora isso não seja necessário.

A maneira mais fácil de instalar o pyQuil é usar o comando do gerenciador de pacotes Python. No prompt de comando do Linux Ubuntu, digite

 pip install pyquil 

para instalação bem-sucedida do software. Como alternativa, se o Anaconda estiver instalado, o pyQuil poderá ser instalado digitando

 conda install −c rigetti pyquil 

na linha de comando. Outra alternativa é baixar o código fonte do repositório git e instalar o software. Para fazer isso, digite os seguintes comandos:

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

Este último método é recomendado para todos os usuários que podem contribuir com o pyQuil. Consulte o guia de depósito do GitHub para obter mais informações.

b. Documentação e Tutoriais

O pyQuil possui excelente documentação publicada na Internet, com uma introdução à computação quântica, instruções de instalação, programas básicos e operações de gateways, um simulador conhecido como máquina virtual quântica (QVM), um computador quântico real e uma linguagem Quil com um compilador. Ao baixar o código-fonte pyQuil do GitHub, você também obterá uma pasta com exemplos nos blocos de anotações Jupyter, exemplos regulares de Python e um programa$$ $ inline $ \ textf {run_quil.py} $ inline $ , que pode executar documentos de texto escritos em Quil usando uma máquina virtual quântica. Por fim, mencione Grove , um conjunto de algoritmos quânticos criados usando o pyQuil e o ambiente da Floresta Rigetti.

c. Sintaxe

A sintaxe pyQuil é muito simples e prática. O principal elemento para a gravação de circuitos quânticos é o programa e pode ser importado de $$$\ messagesf {pyquil.quil}$ . As operações do portão podem ser encontradas em $$$\ textf {pyquil.gates}$ . Módulo $$$\ messagesf {api}$ permite executar circuitos quânticos em uma máquina virtual. Um dos recursos interessantes do pyQuil é que os registros qubit e clássicos não precisam ser definidos a priori e podem ser alocados dinamicamente na memória. Os qubits no registro de qubit são referidos pelos índices (0, 1, 2, ...) e da mesma forma para os bits no registro clássico. Assim, o circuito gerador aleatório pode ser escrito da seguinte maneira:

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

Listagem 2. Código PyQuil para um gerador de números aleatórios.

As três primeiras linhas importam o mínimo necessário para declarar um esquema / programa quântico (linha 2), executar operações de porta em qubits (linha 3) [44] e executar o esquema (linha 4). Na linha 6, um programa quântico é criado e, nas linhas 7-8, uma lista de instruções é transmitida a ele: primeiro, aja no portão Hadamard $$$H$ acima do qubit no índice 0, medimos o mesmo qubit em um bit clássico no índice 0. A linha 10 estabelece uma conexão com o QVM e, às 11, o resultado do nosso circuito é iniciado e exibido. Este programa imprime a saída padrão do pyQuil como uma lista de listas de números inteiros: no nosso caso - $$$\ textf {[[[0]]}$ ou $$$\ messagesf {[[[1]]}$ . Em geral, o número de itens em uma lista externa é o número de testes realizados. Números inteiros em listas internas são as dimensões finais no registro clássico. Como realizamos apenas um teste (isso é indicado como argumento na $$$\ messagesf {api.QVMConnection.run}$ , que está definido como unidade por padrão), obtemos apenas uma lista interna. Como no registro clássico tínhamos apenas um bit, obtivemos apenas um número inteiro.

d. Linguagem quântica

Quil é uma linguagem de instruções quânticas, ou simplesmente uma linguagem quântica que transmite comandos para um computador quântico. Isso é semelhante ao assembler em computadores clássicos. O núcleo da sintaxe Quil é $$$\ messagesf {índice GATE}$ onde $$$\ messagesf {GATE}$ é um portão quântico que se aplica a qubits indexados $$$\ textf {index}$ (0, 1, 2, ...). pyQuil tem uma função para gerar o código Quil a partir de um determinado programa. Por exemplo, no gerador de números aleatórios quânticos mencionado acima, poderíamos adicionar a linha:

 print(qprog) 

no final, para obter o código do diagrama Quil, mostrado abaixo:

 H 0 MEASURE 0 [0] 

Lista 3. Código Quil para um gerador de números aleatórios.

Talvez se alguém começar a entender Quil, escreva circuitos quânticos em um editor de texto em Quil e execute o circuito no QVM usando o programa$$ $ inline $ \ textf {run_quil.py} $ inline $ . Você também pode modificar$$ $ inline $ \ textf {run_quil.py} $ inline $ para executar o circuito na QPU. Observe que o compilador pyQuil (também chamado de compilador Quil na documentação) converte o circuito fornecido em código Quil que um computador quântico real pode entender. Discutiremos isso com mais detalhes na seção III C.

f. Hardware quântico

Rigetti possui um processador quântico que pode ser usado por quem solicita acesso. Para solicitar acesso, você deve visitar o site Rigetti e fornecer o nome completo, endereço de email, nome da organização e uma descrição do motivo para acessar a QPU. Feito isso, um representante da empresa entrará em contato com você por e-mail para agendar um horário para fornecer ao usuário acesso à QPU. A vantagem desse processo de agendamento, em contraste com o sistema de enfileiramento QISKit, que será discutido mais adiante, é que muitas tarefas podem ser executadas em um intervalo de tempo distribuído com tempos de execução determinísticos, o que é essencial para algoritmos variacionais e híbridos. Esses tipos de algoritmos enviam dados entre computadores clássicos e quânticos - a necessidade de esperar na fila torna esse processo muito mais longo. A desvantagem (possivelmente) é que as tarefas não podem ser executadas a qualquer momento quando a QPU está disponível e é necessário indicar e concordar com um horário específico.

De acordo com a experiência do autor, os funcionários estão prontos para ajudar, e o processo geralmente é bem-sucedido. O dispositivo real, cuja topologia é mostrada na Figura 2, consiste em 8 qubits com a conectividade vizinha mais próxima. Veremos este computador com mais detalhes na Seção III B.

g. Simulador

A Máquina Virtual Quântica (QVM) é o principal utilitário usado para executar circuitos quânticos. Este programa, escrito para rodar em um processador clássico, recebe o código Quil e simula o desenvolvimento de um processo em um computador quântico real. Para se conectar ao QVM, é necessário registrar uma chave de API gratuitamente em https://www.rigetti.com/forest com um nome e endereço de email. Você receberá um email contendo a chave da API e o ID do usuário que devem ser configurados na inicialização:

 pyquil−config−setup 

na linha de comando (depois de instalar o pyQuil, é claro). Você será solicitado a inserir as chaves do email.

De acordo com a documentação, a maioria das chaves de API fornece acesso a QVMs de até 30 qubits, e você pode solicitar acesso a mais qubits. A chave API do autor fornece acesso a 26 qubits (nenhuma atualização foi solicitada).

Além disso, a biblioteca Forest contém um simulador local escrito em Python e de código aberto, conhecido como Reference QVM . Não é tão produtivo quanto o QVM, mas os usuários podem executar circuitos com o número de qubits limitados pela quantidade de memória nas máquinas locais. Normalmente, circuitos com menos de 20 qubits podem ser executados em uma ampla gama de equipamentos. O QVM de referência deve ser instalado separadamente, o que pode ser feito com $$$\ textf {pip}$ :

 pip install referenceqvm 

Para usar o QVM de referência em vez do QVM, basta importar $$$\ messagesf {api}$ de $$$\ textf {referenceqvm}$ em vez de pyQuil:

 import referenceapi.api as api 

B. QISKit

O Quantum Information Software Kit, ou QISKit, é um kit de desenvolvimento de software de código aberto (SDK) para trabalhar com a linguagem quântica OpenQASM e processadores quânticos na plataforma IBM Q. Está disponível para as linguagens Python, JavaScript e Swift, mas aqui discutimos apenas Versão Python.

a. Requisitos e instalação

O QISKit está disponível no MacOS, Windows e Linux. A instalação do QISKit requer Python 3.5+. Componentes adicionais úteis, mas não necessários, são os Jupyter Notebooks para tutoriais e a distribuição Python Anaconda 3, que contém todas as dependências necessárias.

A maneira mais fácil de instalar o QISKit é usar o gerenciador de pacotes pip para Python. No prompt de comando, para instalar o software, digite:

 pip install qiskit 

Por favor note que $$$\ textf {pip}$ processa automaticamente todas as dependências e sempre instala a versão mais recente. Os usuários que possam estar interessados ​​em contribuir com o QISKit podem instalar o código-fonte digitando o seguinte em um prompt de comando, presume-se que o git esteja instalado:

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

Para obter informações sobre depósitos, consulte a documentação on-line do guia de depósitos no GitHub.

b. Documentação e materiais de treinamento

A documentação do QISKit pode ser encontrada na Internet em https://qiskit.org/documentation/ . Ele contém instruções de instalação e configuração, programas de amostra e conexão com dispositivos quânticos reais, organização do projeto, uma revisão do QISKit e documentação do desenvolvedor. Informações básicas sobre computação quântica também podem ser encontradas para usuários novos no campo. Um recurso muito bom é um link para o SDK, onde os usuários podem encontrar informações na documentação do código-fonte.

O QISKit também contém um grande número de tutoriais em um repositório GitHub separado (semelhante ao pyQuil e Grove). Isso inclui estados emaranhados; algoritmos padrão como Deutsch Jozh, algoritmo de Grover, estimativa de fase e transformada quântica de Fourier; algoritmos também mais complexos, como resolver um problema de valor próprio de variação quântica e aplicar a Hamiltonianos de férmion; e até alguns jogos divertidos, como a "batalha marítima" quântica. Além disso, a biblioteca ACQUA (Algoritmos e Circuitos para Aplicações de QUantum) contém algoritmos multidisciplinares de química e inteligência artificial com vários exemplos.

Também há documentação muito detalhada para cada um dos quatro back-ends quânticos, contendo informações sobre conectividade, tempo de coerência e tempo de uso do gate. Por fim, mencione o site e os guias do usuário do IBM Q experience. O site contém uma interface gráfica para um circuito quântico no qual os usuários podem arrastar portas para um circuito, o que é útil para explorar circuitos quânticos. Os guias do usuário contêm mais instruções sobre computação quântica e a linguagem QISKit.

c. Sintaxe

A sintaxe QISKit pode ser exibida no seguinte programa de amostra. Aqui, diferentemente do pyQuil, você precisa distinguir explicitamente entre registros quânticos e clássicos. Abaixo está um programa para o esquema de números aleatórios do 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()) 

Listagem 4. Código QISKit para um gerador de números aleatórios.

A linha 2 importa ferramentas para criar registros quânticos e clássicos, um circuito quântico e funções para executar esse circuito. Em seguida, criamos um registro quântico com um qubit (linha 4), um registro clássico com um bit (linha 5) e um circuito quântico com esses dois registros (linha 6). Agora que o circuito é criado, começamos a dar instruções: na linha 8, aplicamos a porta Hadamard ao qubit zero em nosso registro quântico (que é o único qubit no registro quântico); na linha 9, medimos esse qubit em um bit clássico indexado por zero em nosso registro clássico (que é o único no registro clássico) [45]. Agora que o circuito quântico está construído, execute-o na linha 11 e imprima o resultado na linha 12. Por meio da saída$$ $ inline $ \ textf {result.get_counts ()} $ inline $ obtemos os “cálculos” do circuito, ou seja, o dicionário de dados de saída e quantas vezes cada resultado foi recebido. Para o nosso caso, as únicas saídas possíveis são 0 ou 1, e um exemplo da saída do programa acima é $$$\ textf {{'0': 532, '1': 492}}$ , o que indica que temos 532 instâncias de 0 e 492 instâncias de 1. (Por padrão, o número de ciclos para iniciar o circuito chamado $$$\ messagesf {shots}$ no QISKit, é 1024.)

d. Linguagem quântica

O OpenQASM (a linguagem montadora quântica aberta [25], que podemos chamar de QASM) é uma linguagem quântica que fornece instruções para dispositivos quânticos reais semelhantes aos montadores em computadores clássicos. A base da sintaxe QASM é $$$\ messagesf {gate qubit}$ onde $$$\ messagesf {gate}$ define a operação do portão quântico e $$$\ messagesf {qubit}$ - qubit. O QISKit tem uma função para gerar código QASM a partir de um esquema. No esquema de números aleatórios acima, poderíamos adicionar uma linha.

 print(qcircuit.qasm()) 

no final, para obter o código QASM para o circuito mostrado abaixo:

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

Listagem 5. Código OpenQASM para um gerador de números aleatórios.

As duas primeiras linhas estão incluídas em cada arquivo QASM. A linha 3 (4) cria um registro quântico (clássico) e as linhas 5 e 6 dão instruções para o circuito. No OpenQASM, você pode escrever pequenos circuitos como esses, mas para circuitos maiores, é melhor usar ferramentas no QISKit para uma programação livre e eficiente de computadores quânticos.

e Hardware quântico

Existe uma enorme quantidade de documentação para back-ends quânticos suportados pelo QISKit. Esses dispositivos incluem IBMQX2 (5 qubits), IBMQX4 (5 qubits), IBMQX5 (16 qubits) e QS1_1 (20 qubits, disponíveis apenas para membros da IBM Q Network). A documentação para todos está disponível no GitHub. Examinaremos mais de perto o IBMQX5 na Seção III B, cuja topologia é mostrada na Figura 3.

f.

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