Um algoritmo quântico de amostra, útil para demonstrar linguagens

Estou procurando um algoritmo quântico que possa ser usado para demonstrar a sintaxe de diferentes linguagens quânticas. Minha pergunta é semelhante a esta , no entanto, para mim, "bom" significa:

• O que ele faz pode ser descrito em 1 a 2 parágrafos e deve ser fácil de entender.
• Deve usar mais elementos do "mundo da programação quântica" (quero dizer que o algoritmo deve usar constantes clássicas, medições, condições, registros q, operadores etc., o máximo possível).
• O algoritmo deve ser pequeno (no máximo 15 a 25 linhas de pseudo-código).

Algoritmos úteis geralmente são muito longos / difíceis, mas o algoritmo de Deutsch não usa tantos elementos. Alguém pode me sugerir um algoritmo bom para demonstração?

Sugiro olhar para protocolos de estimativa de valor próprio / vetor próprio. Há muita flexibilidade para tornar o problema tão fácil ou difícil quanto você deseja.

Comece escolhendo dois parâmetros, e k . Você deseja projetar um unitário de n qubit, U que possua valores próprios no formato e - 2 π i q / 2 k para números inteiros q . Certifique-se de que pelo menos um desses autovalores seja único e chame-o de ω . Verifique também se um estado simples do produto, digamos | 0 ⟩ ⊗ n , tem diferente de zero sobreposição com o vector próprio de valores próprios ω .$n$$k$$n$$U$$e^{-2\pi iq/2^k}$$q$$\omega$$|0\rangle^{\otimes n}$$\omega$

O objetivo seria implementar um algoritmo de estimativa de fase sobre isso, informando o valor e receber a tarefa de gerar um vetor | ip ⟩ que é o vector próprio correspondente ao valor próprio ω . Em geral, isso incluirá um circuito de n + k qubits (a menos que você precise de ancillas para implementar U controlado ).$k$$|\psi\rangle$$\omega$$n+k$$U$

Isso funciona da seguinte maneira:

• configure dois registros, um de qubits e o outro de n qubits. ( uso de registros quânticos )$k$$n$

• cada qubit é inicializado no estado . ( inicialização de registros quânticos )$|0\rangle$

• aplique um Hadamard a cada qubit no primeiro registro ( portas de um qubit )

• $r$$U^{2^{r}}$

• aplique a conversão inversa de Fourier no primeiro registro e meça cada qubit do primeiro registro na base padrão. Estes podem ser combinados, implementando a transformada semi-clássica de Fourier . ( medição e transmissão de dados clássicos )

• $|\psi\rangle$

$n=2$$k=1$$4\times 4$$\pm 1$

$$(U_1\otimes U_2)C(U_1^\dagger\otimes U_2^\dagger),$$ $C$$|\psi\rangle=(U_1\otimes U_2)|1\rangle\otimes(|0\rangle-|1\rangle)/\sqrt{2}$$U_1$$U_2$$U$$U$

$k=3$$C$

$$\left( \begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & \frac{1}{\sqrt{2}} & \frac{i}{\sqrt{2}} & 0 \\ 0 & \frac{i}{\sqrt{2}} & \frac{1}{\sqrt{2}} & 0 \\ 0 & 0 & 0 & 1 \\ \end{array} \right)$$ $\omega=e^{\pm i\pi/4}$$|\psi\rangle=(U_1\otimes U_2)(|01\rangle\pm|10\rangle)/\sqrt{2}$

Parece que você quer um "Olá Mundo" quântico. A versão quântica mais direta disso seria apenas escrever uma versão codificada binária do texto Hello Worldem um registro de qubits. Mas isso exigiria ~ 100 qubits e seria maior que o seu limite superior para o comprimento do código.

Então, vamos escrever um pequeno pedaço de texto. Vamos escrever ;), precisamos de uma sequência de bits de comprimento 16. Especificamente, usando a codificação ASCII

;)  =  00111011 00101001

Usando o QISKit, você faria isso usando o código a seguir.

from qiskit import QuantumProgram
import Qconfig

qp = QuantumProgram()
qp.set_api(Qconfig.APItoken, Qconfig.config["url"]) # set the APIToken and API url

# set up registers and program
qr = qp.create_quantum_register('qr', 16)
cr = qp.create_classical_register('cr', 16)
qc = qp.create_circuit('smiley_writer', [qr], [cr])

# rightmost eight (qu)bits have ')' = 00101001
qc.x(qr[0])
qc.x(qr[3])
qc.x(qr[5])

# second eight (qu)bits have 00111011
# these differ only on the rightmost two bits
qc.x(qr[9])
qc.x(qr[8])
qc.x(qr[11])
qc.x(qr[12])
qc.x(qr[13])

# measure
for j in range(16):
    qc.measure(qr[j], cr[j])

# run and get results
results = qp.execute(["smiley_writer"], backend='ibmqx5', shots=1024)
stats = results.get_counts("smiley_writer")

Claro, isso não é muito quântico. Então você pode fazer uma superposição de dois emoticons diferentes. O exemplo mais fácil é sobrepor;) com 8), uma vez que as cadeias de bits diferem apenas nos qubits 8 e 9.

;)  =  00111011 00101001
8)  =  00111000 00101001

Então você pode simplesmente substituir as linhas

qc.x(qr[9])
qc.x(qr[8])

do acima com

qc.h(qr[9]) # create superposition on 9
qc.cx(qr[9],qr[8]) # spread it to 8 with a cnot

O Hadamard cria uma superposição de 0e 1, e o nó não o torna uma superposição de 00e 11em dois qubits. Esta é a única superposição necessária para ;)e 8).

Se você quiser ver uma implementação real disso, ela pode ser encontrada no tutorial do QISKit (divulgação completa: foi escrito por mim).

Eu proporia o (perfeito) gerador de números aleatórios de 1 bit. É quase trivialmente fácil:

$\left|0\right>$$H$$\left|0\right>$$\left|1\right>$