🤾🏿 👨🏿‍🍳 💰 O livro "Desenvolvimento usando computadores quânticos" 🥅 👩🏾‍🌾 ✔️

Olá, habrozhiteli! A computação quântica não muda apenas a realidade! Uma indústria completamente nova está nascendo diante de nossos olhos, a fim de criar o impensável antes e desvalorizar algumas das realizações do passado. Este livro discute os componentes mais importantes de um computador quântico: qubits, portas lógicas e circuitos quânticos e também explica a diferença entre a arquitetura quântica e a tradicional. Você pode experimentá-los gratuitamente no simulador e em um dispositivo quântico real usando o IBM Q Experience.

Você aprenderá como os cálculos quânticos são realizados usando o QISKit (ferramentas de software para processamento de informações quânticas), o Python SDK e outras APIs, em particular o QASM.

Finalmente, você estudará algoritmos quânticos modernos que implementam emaranhamento, geração de números aleatórios, pesquisa linear, fatoração de número inteiro e outros. Você lidará com os estados de Bell que descrevem o emaranhamento, o algoritmo de Grover para pesquisa linear, o algoritmo Shore para fatoração de número inteiro, algoritmos de otimização e muito mais. .

Você aprenderá: • Execute programas remotamente usando a API REST do Q Experience. • Escreva algoritmos que oferecem o melhor desempenho em comparação com os análogos para computadores tradicionais. • Crie um cliente REST no Node.js para autenticar, ouvir dispositivos remotos, solicitar informações sobre processadores quânticos, controlar remotamente e executar experimentos na nuvem. • Use teletransporte quântico. Usando cálculos clássicos e emaranhamento quântico entre o remetente e o receptor, transmita o estado exato do qubit (informação quântica). • Programe e jogue a versão quântica do Sea Battle. • Use o Q Experience Composer para criar programas / experiências visuais.

Excerto. Teoria dos Jogos: Com a mecânica quântica, a vantagem está sempre do seu lado

Este capítulo explora dois quebra-cabeças de jogos que demonstram a impressionante superioridade dos algoritmos quânticos sobre seus equivalentes clássicos.

O enigma da moeda falsa. Este é o clássico problema de pesagem proposto pelo matemático E.D. Shell em 1945. Nela, usando uma balança de laboratório para um número limitado de pesagens, é necessário determinar uma moeda cujo peso difere do peso de outras pessoas (falso).
A praça mágica de Mermin - Perez. Este é um exemplo de pseudo telepatia quântica, ou a capacidade dos jogadores de alcançar resultados que são possíveis apenas se lerem os pensamentos um do outro durante o jogo.

Nos dois casos, a computação quântica capacita os jogadores com habilidades pseudo-mágicas, como se estivessem trapaceando o tempo todo. Vamos ver como isso acontece.

O enigma da moeda falsa

O jogador tem oito moedas e uma balança de laboratório. Uma das moedas é falsa e, portanto, pesa menos que as demais. Você pode encontrá-la? Vamos dar uma breve olhada na solução mostrada na fig. 7.1

1. Coloque as moedas 1-3 no lado esquerdo da balança e 4-6 no direito. Separe as moedas 7 e 8.

2. Se o lado direito da balança tiver superado, então é falso - entre as moedas 1-3 (à esquerda). Lembre-se de que a moeda falsa é mais fácil. Em seguida, remova a moeda 3 e coloque a moeda 1 no lado esquerdo da balança e a moeda 2 no lado direito.

Se a taça certa exceder, então a moeda falsa 1.
Se a taça esquerda for superior, então a falsa - moeda 2.
Se a balança estiver equilibrada, a moeda falsa será 3.

3. Se o lado esquerdo da balança tiver superado, o falso - entre as moedas 4–6. Remova a moeda 6 e coloque a moeda 4 no lado esquerdo da balança e a moeda 5 no lado direito.

Se a taça certa exceder, então a moeda falsa 4.
Se a tigela esquerda for superior, então a falsa - moeda 5.
Se a balança estiver equilibrada, a moeda falsa 6.

4. Se a balança estiver equilibrada, a moeda falsificada será 7 ou 8. Coloque a moeda 7 no lado esquerdo da balança e a moeda 8 no lado direito e pese-a.

Se a taça certa exceder, então a moeda falsa 7.
Se a tigela esquerda for superior, a moeda falsificada 8.

O algoritmo clássico pode ser implementado independentemente do número total de moedas N e do número de moedas falsificadas k. Em geral, a complexidade do tempo para o problema generalizado de moeda falsa é O (k log (N / k)).

NOTA
Foi comprovado que são necessárias pelo menos duas tentativas para detectar uma moeda falsificada usando uma balança de laboratório em um computador clássico.

Solução Quântica

Acredite ou não, existe um algoritmo quântico que pode encontrar uma moeda falsa em uma pesagem quântica, independentemente do número de moedas N! De um modo geral, para qualquer número de moedas falsificadas k, independentemente de N, a complexidade temporal de um algoritmo desse tipo é imagem

NOTA O
algoritmo quântico para determinar uma moeda falsa é um exemplo de aceleração de quarto grau em comparação com sua contraparte clássica.

Então, na fig. 7.2 mostra a superioridade do algoritmo quântico sobre a contraparte clássica na solução do enigma da moeda falsa. Vamos considerá-lo em mais detalhes. O algoritmo de busca quântica para uma moeda falsificada imagem

pode ser dividido em três estágios: uma solicitação de pesos quânticos, a criação de pesos quânticos e a definição de uma moeda falsificada.

Etapa 1. Solicitação de pesos quânticos

O algoritmo quântico consultará os pesos quânticos em superposição. Para fazer isso, use uma string de consulta binária para codificar moedas na balança. Por exemplo, a sequência de consulta 11101111 significa que todas as moedas estão nas escalas, exceto a moeda com o índice 3. As escalas são equilibradas se não houver moedas falsificadas e são inclinadas de outra forma. Isso é ilustrado na tabela a seguir.

O algoritmo de ações é o seguinte.

1. Use dois registradores quânticos para consultar pesos quânticos, onde o primeiro registro é para a sequência de consultas e o segundo para o resultado.

2. Prepare uma superposição de todas as sequências de consultas binárias com um número par de unidades.

3. Para obter uma superposição de estados com um número par de unidades, execute a transformação Hadamard no estado base e verifique se o peso de Hamming para | x | até. Pode-se demonstrar que o peso de Hamming para | x | é uniforme se e somente se x1 ⊕ x2 ⊕ ... ⊕ xN = 0.

NOTA
O peso de Hamming (hw) de uma string é o número de caracteres que não sejam o caractere nulo do alfabeto usado. Por exemplo, hw (11101) = 4, hw (11101000) = 4, hw (000000) = 0.

4. Finalmente, meça o segundo registro. Se uma condição for observada imagem

, o primeiro registro será uma superposição de todas as seqüências de consultas binárias desejadas. Se recebido imagem

, você precisará repetir o procedimento até que uma condição seja observada. imagem

Note que a cada repetição, a probabilidade de sucesso é exatamente 0,5. No entanto, após várias repetições, podemos obter a superposição desejada de estados. A Listagem 7.1 mostra a implementação do programa quântico para consultar os pesos, e o diagrama gráfico correspondente é mostrado na Fig. 7.3

NOTA
Para simplificar a percepção, o programa para determinar uma moeda falsa é dividido nas listagens 7.1 a 7.3. Embora eu espero que você possa combinar essas listagens para executar o programa, o código completo está na fonte do arquivo Workspace\Ch07\p_counterfeitcoin.py.

Listagem 7.1. Script de consulta de pesos quânticos

# -------    
Q_program = QuantumProgram()
Q_program.set_api(Qconfig.APItoken, Qconfig.config["url"])

#  numberOfCoins +1 / 
#      
#  
qr = Q_program.create_quantum_register("qr", numberOfCoins + 1)

#     qr
cr = Q_program.create_classical_register("cr", numberOfCoins + 1)

circuitName = "QueryStateCircuit"
circuit = Q_program.create_circuit(circuitName, [qr], [cr])

N = numberOfCoins

#       N
for i in range(N):
     circuit.h(qr[i])

#  XOR(x)     CNOT  qr[0]
#  qr[N–1]     qr[N]
for i in range(N):
     circuit.cx(qr[i], qr[N])

#  qr[N]     cr[N]. ,
#  cr[N]  ,     
circuit.measure(qr[N], cr[N])

#     ,     
# cr[0]...cr[N],     |1>,
#   |0> - |1>  qr[N]
circuit.x(qr[N]).c_if(cr, 0)
circuit.h(qr[N]).c_if(cr, 0)

#      cr[N]
for i in range(N):
     circuit.h(qr[i]).c_if(cr, 2**N)

Na fig. 7.3 é um esboço completo do quebra-cabeça de moedas falsas com oito moedas e um falso com o índice 6. Ele mostra todas as etapas descritas aqui para a plataforma IBM Q Experience. O segundo estágio do algoritmo é a criação de pesos.

Etapa 2. Criando pesos quânticos

Na seção anterior, criamos uma superposição de todas as seqüências de consultas binárias para as quais o peso de Hamming é par. Nesta etapa, crie um balanceador quântico, definindo a posição da moeda falsa. Assim, se k é a posição da moeda falsificada em relação à cadeia binária, imagem

as escalas quânticas retornarão:

Isso é implementado usando a porta CNOT com xk como o qubit de controle e o segundo registrador como o destino (consulte a Listagem 7.2).

Listagem 7.2. Criando pesos quânticos

#-----   
k = indexOfFalseCoin

#       
# (  cr,  )
circuit.cx(qr[k], qr[N]).c_if(cr, 0)

Etapa 3. Identifique uma moeda falsa

Para revelar uma moeda falsa após uma consulta nos pesos, aplique a conversão Hadamard à cadeia de caracteres da consulta binária. Supõe-se que estamos fazendo uma consulta sobre pesos quânticos com cadeias binárias com um peso de Hamming uniforme, portanto, após ter realizado uma medição na base computacional após a transformação Hadamard, podemos determinar uma moeda falsa, pois apenas seu rótulo difere da maioria dos rótulos (consulte a Listagem 7.3).

Listagem 7.3. Definição de moeda falsa

# ---   
#     qr[0] ... qr[N-1]
for i in range(N):
     circuit.h(qr[i]).c_if(cr, 0)

#  qr[0] ... qr[N–1]
for i in range(N):
     circuit.measure(qr[i], cr[i])

results = Q_program.execute([circuitName], backend=backend, shots=shots)
answer = results.get_counts(circuitName)

print("Device " + backend + " counts " + str(answer))

#     
for key in answer.keys():
     normalFlag, _ = Counter(key[1:]).most_common(1)[0]

for i in range(2,len(key)):
     if key[i] != normalFlag:
          print("False coin index is: ", len(key) - i - 1)

Quando o bit mais à esquerda é 0, o índice de moeda falsificada pode ser determinado localizando aquele cujo peso é diferente do peso dos outros. Por exemplo, com N = 8 e índice de moedas falsas 6, o resultado deve ser 010111111 ou 001000000. Observe que, como usamos cr [N] para controlar a operação antes e depois da solicitação de pesos:

se o bit mais à esquerda for 0, identificamos com sucesso a moeda falsificada;
se o bit mais à esquerda for 1, não obtivemos a superposição desejada e devemos repetir o processo novamente.

Ao executar o programa em um simulador remoto do IBM Q Experience, você obterá o resultado mostrado no código-fonte do livro Workspace\Ch07\p_counterfeitcoin.py. Observe que eu uso o Windows: se você não tem acesso ao código-fonte do livro, mas ainda deseja experimentar esse script, coloque os trechos de código das seções anteriores no contêiner de scripts da Lista 7.4 (verifique o recuo, esse recurso de sintaxe do Python é simples louco). Listagem 7.4. O contêiner principal de script para o enigma de moeda falsa

c:\python36-64\python.exe p_counterfeitcoin.py
Device ibmq_qasm_simulator counts {'001000000': 1}
False coin index is: 6

import sys
import matplotlib.pyplot as plt
import numpy as np
from math import pi, cos, acos, sqrt
from collections import Counter
from qiskit import QuantumProgram
sys.path.append('../Config/')
import Qconfig

#      
import basic plot tools
from qiskit.tools.visualization import plot_histogram

def main(M = 16, numberOfCoins = 8 , indexOfFalseCoin = 6
      , backend = "local_qasm_simulator" , shots = 1 ):

      if numberOfCoins < 4 or numberOfCoins >= M:
           raise Exception("Please use numberOfCoins between 4 and ", M-1)
      if indexOfFalseCoin < 0 or indexOfFalseCoin >= numberOfCoins:
           raise Exception("indexOfFalseCoin must be between 0 and ",
           numberOfCoins-1)

      //   7.1–7.3 

#################################################
# main
#################################################
if __name__ == '__main__':
     M = 8                      #    
     numberOfCoins = 4          #  M-1,  M —   
     indexOfFalseCoin = 2             #   0, 1... numberOfCoins — 1

     backend = "ibmq_qasm_simulator"
     #backend = "ibmqx3"
     shots = 1                         #      

     main(M, numberOfCoins, indexOfFalseCoin, backend, shots)

Algoritmo generalizado para qualquer número de moedas falsificadas

Para resolver o enigma das moedas falsas, os matemáticos Terhal e Smolin em 1998 criaram um algoritmo generalizado para qualquer número de moedas falsas (k> 1). Em sua implementação, o modelo "B-oracle" ("oracle equilibrado") é usado, enquanto:

na entrada
uma string de consulta é criada, consistindo em N triplos de bits, de modo que com o mesmo número de 1 e –1;
a resposta é uma dessas que

NOTA O
Oracle faz parte do algoritmo, considerado como uma caixa preta. É usado para simplificar esquemas e comparar a complexidade dos algoritmos quânticos e clássicos. Um bom oráculo deve ser rápido, versátil e fácil de implementar.

Um exemplo do uso do oráculo B para duas moedas falsas com k = 2 e N = 6 é mostrado na Fig. 7.4

Em geral, o enigma da moeda falsa é um exemplo típico da aceleração do algoritmo quântico em comparação com a contraparte clássica. Na próxima seção, consideraremos outro quebra-cabeça pseudo-mágico peculiar chamado “o quadrado mágico de Mermin - Perez”.

Sobre o autor

Vladimir Silva se formou na Middle TN State University com um mestrado em Ciência da Computação. Por cinco anos, ele trabalhou na IBM como Engenheiro de Pesquisa, onde ganhou uma rica experiência em computação distribuída e GRID.

Vladimir possui muitos certificados, incluindo OCP (Oracle Certified Professional), MCSD (Microsoft Certified Solutions Developer) e MCP (Microsoft Certified Professional). Ele também é autor de um grande número de artigos técnicos para o site IBM developerWorks. Ele escreveu os seguintes livros: Computação em grade para desenvolvedores (Charles River Media), Plataforma Prática de Cliente Rico em Eclipse (Apress), Jogos para Android Pro (Apress) e Jogos para Android 4 avançados (Apress).

Vladimir é um ávido corredor de maratona que participou de 16 corridas na Carolina do Norte (no momento em que escrevi). Ele adora tocar violão clássico e refletir sobre coisas incríveis como a mecânica quântica.

Sobre editores de ciências

Edição original

Jason Whitehorn é um empreendedor experiente e desenvolvedor de software. Ele ajudou muitas empresas de petróleo e gás a automatizar e melhorar sua tecnologia por meio da coleta de dados operacionais, SCADA (Controle Supervisório e Aquisição de Dados) e aprendizado de máquina. Jason se formou na Arkansas State University com um diploma de bacharel em Ciência da Computação.

Jason adora passar o tempo livre com sua esposa e quatro filhos. Vive em Tulsa, Oklahoma. Mais informações sobre Jason podem ser encontradas no site jason.whitehorn.us .

Edição russa

Mikhail Korobko- um físico, está envolvido em teoria e experimentos sobre a aplicação da óptica quântica, optomecânica e medições quânticas para melhorar a sensibilidade dos detectores de ondas gravitacionais. Desde 2012, é membro da colaboração internacional de cientistas no detector de ondas gravitacionais LIGO.

Mikhail se formou no Departamento de Física da Universidade Estadual de Moscou. Lomonosov, atualmente é aluno do Instituto de Física a Laser da Universidade de Hamburgo. Ele passa seu tempo livre com sua família, escreve artigos científicos populares sobre física quântica e publica posts no Twitter (@hbar_universe).

»Mais informações sobre o livro podem ser encontradas no site da editora
» Tabela de conteúdos
» Trecho

para Savingbenders Cupom de desconto de 25% - Silva

Após o pagamento da versão impressa do livro, um livro eletrônico é enviado por e-mail.

O livro "Desenvolvimento usando computadores quânticos"