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). $|\Psi_0\rangle$ $|b\rangle$

| Ψ_{0} ⟩ = \sqrt{\frac{2}{T}} \sum_{τ = 0}^{T - 1} \sin \frac{π (τ + \frac{1}{2})}{T} | τ ⟩

$|\Psi_0\rangle = \sqrt{\frac{2}{T}}\sum_{\tau = 0}^{T-1}\sin \frac{\pi (\tau+\frac{1}{2})}{T}|\tau\rangle$

| b ⟩ = \sum_{1}^{N} b_{i} | i ⟩

$|b\rangle = \sum_{1}^{N}b_i|i\rangle$

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

(Digamos) Quero executar o algoritmo deles no computador quântico de bits da IBM . $16$ E 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:

A = [\begin{matrix} 1 & 2 & 3 & 4 \\ 2 & 1 & 5 & 6 \\ 3 & 5 & 1 & 7 \\ 4 & 6 & 7 & 1 \end{matrix}]

$\mathbf{A} = \begin{bmatrix} 1 & 2 & 3 & 4 \\ 2 & 1 & 5 & 6 \\ 3 & 5 & 1 & 7 \\ 4 & 6 & 7 & 1 \end{bmatrix}$

b = [\begin{matrix} 1 \\ 2 \\ 3 \\ 4 \end{matrix}]

$\mathbf{b}=\begin{bmatrix} 1 \\ 2 \\ 3 \\ 4 \end{bmatrix}$

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). $\mathbf{A}$ $\mathbf{b}$ $\lceil{\log_2 4\rceil}=2$ $6$ $90\%$ $3$ $2+6+1=9$ $1$

Questões:

Usando essas informações, é possível criar os estados iniciais e na versão IBM qubit? $|\Psi_0\rangle$ $|b\rangle$ $16$
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). $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? $|\Psi_0\rangle$ $|b\rangle$

— Sanchayan Dutta
fonte

Tanto quanto sei, a IBM não pode fazer HHL porque envolve fazer coisas em uma superposição de momentos diferentes, mas não ficaria surpreso se estiver errado. @ James Woottoon pode saber a resposta melhor.

— user1271772

@ user1271772 Eu também pensava assim, mas sou um pouco cético porque alguém me disse no chat que simulava o HHL por após isso , na IBM.

4 \times 4

$4\times 4$

— Sanchayan Dutta

Bem, talvez a Figura 4 do artigo de Yudong Cao (a que você vinculou) seja tudo o que você precisa então.

— user1271772

@ user1271772 Sim, mas infelizmente isso funcionaria apenas para essa matriz específica. Estou procurando uma técnica geral, pela qual provavelmente deveria ler esse artigo mais detalhadamente.

— Sanchayan Dutta

Como John Watrous colocou em um de seus comentários para uma pergunta em que alguém estava pedindo um circuito específico, "você está pedindo que as pessoas façam um trabalho tedioso, mas conceitualmente desinteressante". Yudong era um estudante de engenharia quando fez esses circuitos. Ele não teve mais treinamento do que você (de fato, com base em seu rápido progresso, você provavelmente sabe mais sobre computação quântica do que ele na época em que escrevia esse artigo). Se ele puder fazer esse circuito, você poderá fazer o circuito correspondente para qualquer exemplo de HHL que vier à sua frente.

— user1271772

Respostas:

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

Aqui você pede 2 estados quânticos diferentes:

$\left| b \right>$ $\left| b \right>$ $N$
$\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).

— Nelimee
fonte

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.

— Bram
fonte

O problema com a implementação de 4x4 HHL não é o número de qubits (são necessários 7 qubits), mas as taxas de erro de portas quânticas e os tempos de decoerência. Uma implementação de um sistema 4x4 usando o QISKit está disponível aqui . A implementação segue arxiv.org/abs/1110.2232v2 .

— Nelimee 6/07

Ótima implementação de um HHL 4 x 4.

— Bram