Algoritmo quântico para sistemas lineares de equações (HHL09): Etapa 2 - Preparação dos estados iniciais

^{Esta é uma continuação do algoritmo Quantum para sistemas lineares de equações (HHL09): Etapa 2 - O que é ?$|\Psi_0\rangle$}

No artigo: Algoritmo quântico para sistemas lineares de equações (Harrow, Hassidim & Lloyd, 2009) , os detalhes da implementação real do algoritmo não são fornecidos. Como exatamente os estados e são criados, é uma espécie de " caixa preta " (consulte as páginas 2-3).| b $|\Psi_0\rangle$$|b\rangle$

e

onde é o estado inicial do registro do relógio e é o estado inicial do registro de Entrada.| b $|\Psi_0\rangle$$|b\rangle$

(Digamos) Quero executar o algoritmo deles no computador quântico de bits da IBM . $16$A x = b A 4 × 4 b 4 × 1E eu quero resolver uma certa equação que é uma matriz hermitiana com entradas reais e é um vetor de coluna com entradas reais.$\mathbf{Ax=b}$$\mathbf{A}$$4\times 4$$\mathbf{b}$$4\times 1$

Vamos dar um exemplo:

e

Dadas as dimensões de e , precisamos de qubits para o registro de entrada e outros qubits para o registro de relógio, assumindo que queremos que os autovalores sejam representado com precisão de e precisão de até bits para os valores próprios (isso foi discutido aqui anteriormente). Portanto , serão necessários qubits para esse fim (o qubit extra é o ancilla).b ⌈ log 2 4 ⌉ = 2 6 90 % 3 2 + 6 + 1 = 9 $\mathbf{A}$$\mathbf{b}$$\lceil{\log_2 4\rceil}=2$$6$$90\%$$3$$2+6+1=9$$1$

Questões:

1. Usando essas informações, é possível criar os estados iniciais e na versão IBM qubit?| b ⟩ $|\Psi_0\rangle$$|b\rangle$$16$

2. Se você acha que é muito grande para ser implementado nos computadores quânticos da IBM, você pode até mostrar um exemplo de preparação inicial do estado para uma matriz hermitiana (ou apenas fazer uma referência a essa exemplo).2 × 2 $4\times 4$$2\times 2$$\mathbf{A}$

Eu simplesmente quero ter uma idéia geral sobre se isso pode ser feito (ou seja, se é possível) no computador quântico IBM de 16 qubit e para quais portas serão necessárias. Se não for o computador quântico de 16 qubit da IBM, o simulador QISKit pode ser usado para recriar a preparação inicial do estado de e no algoritmo HHL? Existe alguma outra alternativa melhor para fazer isso?| b $|\Psi_0\rangle$$|b\rangle$

$\left| \Psi_0\right>$$\left|b\right>$

Aqui você pede 2 estados quânticos diferentes:

1. $\left| b \right>$$\left| b \right>$$N$
2. $\left| \Psi_0 \right>$$\left| b \right>$$b_i$

$\left|b\right>$$\left| \Psi_0 \right>$$\left| \Psi_0 \right>$$\left| \Psi_0 \right>$

$\left|b\right>$$\left|\Psi_0\right>$

$\left|\Psi_0\right>$$\left|\Psi_0\right>$

Para a implementação no QISKit, aqui está uma amostra para inicializar um determinado estado quântico:

import qiskit

statevector_backend = qiskit.get_backend('local_statevector_simulator')

###############################################################
# Make a quantum program for state initialization.
###############################################################
qubit_number = 5
Q_SPECS = {
    "name": "StatePreparation",
    "circuits": [
        {
            "name": "initializerCirc",
            "quantum_registers": [{
                "name": "qr",
                "size": qubit_number
            }],
            "classical_registers": [{
                "name": "cr",
                "size": qubit_number
            }]},
    ],
}
Q_program = qiskit.QuantumProgram(specs=Q_SPECS)

## State preparation
import numpy as np
from qiskit.extensions.quantum_initializer import _initializer

def psi_0_coefficients(qubit_number: int):
    T = 2**qubit_number
    tau = np.arange(T)
    return np.sqrt(2 / T) * np.sin(np.pi * (tau + 1/2) / T)

def get_coeffs(qubit_number: int):
    # Can be changed to anything, the initialize function will take
    # care of the initialisation.
    return np.ones((2**qubit_number,)) / np.sqrt(2**qubit_number)
    #return psi_0_coefficients(qubit_number)

circuit_prep = Q_program.get_circuit("initializerCirc")
qr = Q_program.get_quantum_register("qr")
cr = Q_program.get_classical_register('cr')
coeffs = get_coeffs(qubit_number)
_initializer.initialize(circuit_prep, coeffs, [qr[i] for i in range(len(qr))])

res = qiskit.execute(circuit_prep, statevector_backend).result()
statevector = res.get_statevector("initializerCirc")
print(statevector)

¹ Aqui "erro" refere-se ao erro entre o estado ideal e a aproximação ao lidar com um computador quântico perfeito (ou seja, sem decoerência, sem erro de porta).

O algoritmo HHL com uma matriz 4 x 4 A pode ser muito grande para o computador IBM. Eu tentei uma versão menor do algoritmo em brinquedo, de acordo com o arXiv 1302.1210 link Resolvendo sistemas de equações lineares

Expliquei um pouco sobre esse circuito aqui em stackexchange: /cs/76525/could-a-quantum-computer-perform-linear-algebra-faster-than-a-classical-computer/ 77036 # 77036

Infelizmente, é apenas uma entrada de 1 qubit com matriz A = 2 x 2, na resposta é fornecido um link para o circuito IBM.