Algoritmo quantistico per sistemi lineari di equazioni (HHL09): Fase 2 - Preparazione degli stati iniziali e

^{Questa è una continuazione dell'algoritmo Quantum per i sistemi lineari di equazioni (HHL09): Step 2 - Che cos'è ?$|\Psi_0\rangle$}

Nel documento: algoritmo quantistico per sistemi lineari di equazioni (Harrow, Hassidim & Lloyd, 2009) , non vengono forniti i dettagli dell'attuazione effettiva dell'algoritmo. Come vengono creati esattamente gli stati e , è una specie di " scatola nera " (vedere le pagine 2-3).| b $|\Psi_0\rangle$$|b\rangle$

e

dove è lo stato iniziale del registro di clock e è lo stato iniziale del registro di input.| b $|\Psi_0\rangle$$|b\rangle$

(Say) Voglio eseguire il loro algoritmo sul computer quantistico IBM a qubit. $16$E voglio risolvere una certa equazione dove è una matrice eremitica con voci reali e è un vettore di colonna con voci reali.A 4 × 4 b 4 × $\mathbf{Ax=b}$$\mathbf{A}$$4\times 4$$\mathbf{b}$$4\times 1$

Facciamo un esempio:

e

Date le dimensioni di e , dovremmo aver bisogno di qubit per il registro di input e altri qubit per il registro di clock supponendo che vogliamo che gli autovalori siano rappresentato con un'accuratezza del e una precisione fino a bit per gli autovalori (questo è stato discusso qui in precedenza). Quindi, in totale saranno necessari qubit per questo scopo (l'extra qubit è l'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$

Domande:

1. Utilizzando queste informazioni, è possibile creare gli stati iniziali e sulla versione IBM qubit?| b ⟩ $|\Psi_0\rangle$$|b\rangle$$16$

2. Se pensi che sia troppo grande per essere implementato sui computer quantistici IBM, potresti persino mostrare un esempio di preparazione dello stato iniziale per una matrice ermitiana (o semplicemente dare un riferimento a tale esempio).2 × 2 $4\times 4$$2\times 2$$\mathbf{A}$

Voglio semplicemente avere un'idea generale sul fatto che ciò possa essere fatto (cioè se è possibile) sul computer quantistico IBM a 16 qubit e per ciò che sarà necessario. Se non il computer quantistico IBM a 16 qubit, il simulatore QISKit può essere utilizzato per ricreare la preparazione dello stato iniziale di e nell'algoritmo HHL? C'è un'altra alternativa migliore per fare questo?| b $|\Psi_0\rangle$$|b\rangle$

Non è possibile creare gli stati iniziali e sulla versione di IBM 16 qubit. D'altra parte, è possibile approssimarli con un errore arbitrariamente basso ¹ poiché le porte implementate dai chip IBM offrono questa possibilità.| b $\left| \Psi_0\right>$$\left|b\right>$

Qui chiedi 2 diversi stati quantistici:

1. | b ⟩$\left| b \right>$ non è affatto limitato. Lo stato è rappresentato da un vettore di numeri complessi che possono essere qualsiasi cosa (purché il vettore abbia una norma unitaria).$\left| b \right>$$N$
2. | b ⟩ b $\left| \Psi_0 \right>$ può essere visto come un caso speciale di , dove i coefficienti sono più vincolati.$\left| b \right>$$b_i$

Con questa analisi, qualsiasi metodo che può essere utilizzato per creare può anche essere usato per creare . D'altra parte, come è più limitato, possiamo sperare che esistano algoritmi più efficienti per produrre .| Ψ 0 ⟩ | Ψ 0 ⟩ | Ψ 0 $\left|b\right>$$\left| \Psi_0 \right>$$\left| \Psi_0 \right>$$\left| \Psi_0 \right>$

Utile per e| Ψ 0 $\left|b\right>$$\left|\Psi_0\right>$ : basato sulla sintesi dei circuiti logici quantistici (Shende, Bullock e Markov, 2006) , QISKit Python SDK implementa un metodo generico per inizializzare uno stato quantico arbitrario .

Utile per$\left|\Psi_0\right>$ : la creazione di sovrapposizioni che corrispondono a distribuzioni di probabilità integrabili in modo efficiente (Grover & Rudolph, 2002) presenta rapidamente un algoritmo per inizializzare uno stato le cui ampiezze rappresentano una distribuzione di probabilità nel rispetto di alcuni vincoli. Questi vincoli sono rispettati per secondo l' algoritmo Quantum per la risoluzione di sistemi lineari di equazioni (Harrow, Hassidim & Lloyd, 2009) , ultima riga della pagina 5. | Ψ 0 ⟩$\left|\Psi_0\right>$

Per l'implementazione su QISKit, ecco un esempio per inizializzare un dato stato quantico:

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)

¹ Qui "errore" si riferisce all'errore tra lo stato ideale e l'approssimazione quando si ha a che fare con un computer quantistico perfetto (cioè nessuna decoerenza, nessun errore di gate).

L'algoritmo HHL con una matrice 4 x 4 A potrebbe essere troppo grande per il computer IBM. Ho provato una versione giocattolo più piccola dell'algoritmo secondo il collegamento arXiv 1302.1210 Risoluzione di sistemi di equazioni lineari

Ho spiegato un po 'di questo circuito qui su stackexchange: /cs/76525/could-a-quantum-computer-perform-linear-algebra-faster-than-a-classical-computer/ 77036 # 77036

Purtroppo è solo un input da 1 qubit con matrice A = 2 x 2, nella risposta viene fornito un collegamento al circuito IBM.