Quantenalgorithmus für lineare Gleichungssysteme (HHL09): Schritt 2 - Vorbereitung der Anfangszustände

^{Dies ist eine Fortsetzung des Quantenalgorithmus für lineare Gleichungssysteme (HHL09): Schritt 2 - Was ist ? $|\Psi_0\rangle$}

In der Arbeit: Quantenalgorithmus für lineare Gleichungssysteme (Harrow, Hassidim & Lloyd, 2009) werden die Details der tatsächlichen Implementierung des Algorithmus nicht angegeben. Wie genau die Staaten und erstellt werden, ist eine Art " Black-Box " (siehe Seiten 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$

und

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

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

wo ist der Anfangszustand des Taktregisters und ist der Anfangszustand des Eingangsregisters. $|\Psi_0\rangle$ $|b\rangle$

(Sprich) Ich möchte ihren Algorithmus auf dem IBM Qubit-Quantencomputer ausführen. $16$ Und ich möchte eine bestimmte Gleichung lösen, wobei eine Hermitianische Matrix mit reellen Einträgen und ein Spaltenvektor mit reellen Einträgen ist. $\mathbf{Ax=b}$ $\mathbf{A}$ $4\times 4$ $\mathbf{b}$ $4\times 1$

Nehmen wir ein Beispiel:

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}$

und

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

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

$\mathbf{A}$ $\mathbf{b}$ $\lceil{\log_2 4\rceil}=2$ $6$ $90\%$ $3$ $2+6+1=9$ $1$

Fragen:

$|\Psi_0\rangle$ $|b\rangle$ $16$
$4\times 4$ $2\times 2$ $\mathbf{A}$

$|\Psi_0\rangle$ $|b\rangle$

algorithm ibm-q-experience qiskit hhl-algorithm Sanchayan Dutta
quelle

Soweit ich weiß, kann IBM HHL nicht ausführen, da es sich um Dinge handelt, die zu unterschiedlichen Zeiten überlagert sind, aber ich wäre nicht überrascht, wenn ich mich irre. @ James Woottoon könnte die Antwort besser kennen.

user1271772

4 \times 4

$4\times 4$

Nun, vielleicht ist Abb. 4 von Yudong Caos Papier (das, das Sie verlinkt haben) alles, was Sie dann brauchen.

user1271772

@ user1271772 Ja, aber leider würde das nur für diese bestimmte Matrix funktionieren . Ich suche nach einer allgemeinen Technik, für die ich das Papier wahrscheinlich gründlicher lesen sollte.

Sanchayan Dutta

Wie John Watrous es in einem seiner Kommentare zu einer Frage formulierte, in der jemand nach einer bestimmten Schaltung fragte: "Sie fordern die Leute auf, mühsame, aber konzeptionell uninteressante Arbeit zu leisten." Yudong war ein Student der Ingenieurwissenschaften, als er diese Schaltungen herstellte. Er hatte nicht mehr Training als Sie (aufgrund Ihrer schnellen Fortschritte wissen Sie wahrscheinlich mehr über Quantencomputer als zum Zeitpunkt des Schreibens dieses Papiers). Wenn er diese Schaltung machen könnte, sollten Sie in der Lage sein, die entsprechende Schaltung für jedes HHL-Beispiel zu machen, das vor Ihnen liegt.

user1271772

Antworten:

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

Hier fragen Sie nach 2 verschiedenen Quantenzuständen:

$\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>$

Für die Implementierung in QISKit finden Sie hier ein Beispiel zum Initialisieren eines bestimmten Quantenzustands:

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)

¹ Hier bezieht sich "Fehler" auf den Fehler zwischen dem Idealzustand und der Approximation beim Umgang mit einem perfekten Quantencomputer (dh keine Dekohärenz, kein Gate-Fehler).

Nelimee
quelle

Der HHL-Algorithmus mit einer 4 x 4-Matrix A ist möglicherweise zu groß für den IBM-Computer. Ich habe eine kleinere Spielzeugversion des Algorithmus gemäß arXiv 1302.1210 link ausprobiert. Lösen von linearen Gleichungssystemen

Ich habe hier bei stackexchange ein wenig über diese Schaltung erklärt: /cs/76525/could-a-quantum-computer-perform-linear-algebra-faster-than-a-classical-computer/ 77036 # 77036

Leider handelt es sich nur um einen 1-Qubit-Eingang mit einer A = 2 x 2-Matrix. In der Antwort wird eine Verknüpfung zur IBM-Schaltung angegeben.

Bram
quelle

Das Problem bei der 4x4-HHL-Implementierung ist nicht die Anzahl der Qubits (7 Qubits werden benötigt), sondern die Quantengatterfehlerraten und die Dekohärenzzeiten. Eine Implementierung eines 4x4-Systems mit QISKit finden Sie hier . Die Implementierung folgt arxiv.org/abs/1110.2232v2 .

Nelimee

Tolle Implementierung eines 4 x 4 HHL.

Bram