Algorithme quantique pour les systèmes linéaires d'équations (HHL09): Étape 2 - Préparation des états initiaux

^{Il s'agit d'une continuation de l' algorithme quantique pour les systèmes linéaires d'équations (HHL09): Étape 2 - Qu'est-ce que ? $|\Psi_0\rangle$}

Dans l'article: Algorithme quantique pour les systèmes linéaires d'équations (Harrow, Hassidim et Lloyd, 2009) , les détails de la mise en œuvre réelle de l'algorithme ne sont pas donnés. La façon exacte dont les états et sont créés est en quelque sorte une " boîte noire " (voir pages 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$

où est l'état initial du registre d'horloge et est l'état initial du registre d'entrée. $|\Psi_0\rangle$ $|b\rangle$

(Dis) Je veux exécuter leur algorithme sur l'ordinateur quantique IBM à bits. $16$ Et je veux résoudre une certaine équation où est une matrice hermitienne avec des entrées réelles et est un vecteur de colonne avec des entrées réelles. $\mathbf{Ax=b}$ $\mathbf{A}$ $4\times 4$ $\mathbf{b}$ $4\times 1$

Prenons un exemple:

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

Étant donné les dimensions de et , nous devrions avoir besoin de qubits pour le registre d'entrée et autres qubits pour le registre d'horloge en supposant que nous voulons que les valeurs propres soient représenté avec une précision de et une précision jusqu'à bits pour les valeurs propres (cela a été discuté ici précédemment). Un total de qubits sera donc nécessaire à cet effet (le qubit supplémentaire est l'ancilla). $\mathbf{A}$ $\mathbf{b}$ $\lceil{\log_2 4\rceil}=2$ $6$ $90\%$ $3$ $2+6+1=9$ $1$

Des questions:

À l'aide de ces informations, est-il possible de créer les états initiaux et sur la version IBM qubit? $|\Psi_0\rangle$ $|b\rangle$ $16$
Si vous pensez que est trop grand pour être implémenté sur les ordinateurs quantiques IBM, vous pouvez même montrer un exemple de préparation d'état initial pour une matrice hermitienne (ou simplement donner une référence à un tel exemple). $4\times 4$ $2\times 2$ $\mathbf{A}$

Je veux simplement avoir une idée générale de savoir si cela peut être fait (c'est-à-dire si c'est possible) sur l'ordinateur quantique IBM 16 qubits, et pour cela, quelles portes seront nécessaires. Si ce n'est pas l'ordinateur quantique IBM à 16 qubits, le simulateur QISKit peut-il être utilisé pour recréer la préparation de l'état initial de et dans l'algorithme HHL? Existe-t-il une autre meilleure alternative pour y parvenir? $|\Psi_0\rangle$ $|b\rangle$

— Sanchayan Dutta
source

Pour autant que je sache, IBM ne peut pas faire de HHL car cela implique de faire les choses à une superposition de moments différents, mais je ne serais pas surpris si je me trompe. @James Woottoon connaît peut-être mieux la réponse.

— user1271772

@ user1271772 Je le pensais aussi, mais je suis un peu sceptique car quelqu'un m'a dit dans le chat qu'il avait simulé la HHL pendant après cela , sur IBM.

4 \times 4

$4\times 4$

— Sanchayan Dutta

Eh bien, peut-être que la figure 4 du document de Yudong Cao (celui que vous avez lié) est tout ce dont vous avez besoin.

— user1271772

@ user1271772 Oui, mais malheureusement, cela ne fonctionnerait que pour cette matrice particulière. Je recherche une technique générale, pour laquelle je devrais probablement lire cet article plus attentivement.

— Sanchayan Dutta

Comme John Watrous l'a dit dans un de ses commentaires à une question où quelqu'un demandait un circuit spécifique, "vous demandez aux gens de faire un travail fastidieux mais conceptuellement peu intéressant". Yudong était un étudiant en génie de premier cycle quand il a fait ces circuits. Il n'avait pas reçu plus de formation que vous (en fait, compte tenu de vos progrès rapides, vous en savez probablement plus sur l'informatique quantique qu'au moment de la rédaction de cet article). S'il pouvait faire ce circuit, vous devriez pouvoir faire le circuit correspondant pour n'importe quel exemple HHL qui se présente devant vous.

— user1271772

Réponses:

Il n'est pas possible de créer les états initiaux et sur la version IBM 16 qubits. En revanche, il est possible de les rapprocher avec une erreur arbitrairement faible ¹ car les portes implémentées par les puces IBM offrent cette possibilité. $\left| \Psi_0\right>$ $\left|b\right>$

Ici, vous demandez 2 états quantiques différents:

nelimite pas du tout. L'Etat est représenté par un vecteur de nombres complexes qui peuvent être quelque chose (tant que le vecteur estnorme unitaire). $\left| b \right>$ $\left| b \right>$ $N$
peut être considéré comme un cas particulier de , où les coefficients sont plus limités. $\left| \Psi_0 \right>$ $\left| b \right>$ $b_i$

Avec cette analyse, toute méthode pouvant être utilisée pour créer peut également être utilisé pour créer . D'autre part, comme est plus limitée, nous pouvons espérer qu'il existe des algorithmes plus efficaces pour produire . $\left|b\right>$ $\left| \Psi_0 \right>$ $\left| \Psi_0 \right>$ $\left| \Psi_0 \right>$

Utile pour et $\left|b\right>$ $\left|\Psi_0\right>$ : Basé sur la synthèse de circuits logiques (Quantum Shende, Bullock et Markov, 2006) , le QISKit SDK Python met en œuvre une méthode générique pour initialiser un état quantique arbitraire.

Utile pour $\left|\Psi_0\right>$ : Création des superpositions qui correspondent à des distributions de probabilité efficacement intégrables (Grover & Rudolph, 2002) présente rapidement un algorithme pour initialiser un état dont les amplitudes représente une distribution de probabilité en respectant certaines contraintes. Ces contraintes sont respectées pour selon l' algorithme quantique pour résoudre des systèmes d'équations linéaires (Harrow, Hassidim & Lloyd, 2009) , dernière ligne de la page 5. $\left|\Psi_0\right>$

Pour l'implémentation sur QISKit, voici un exemple pour initialiser un état quantique donné:

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)

¹ Ici, "erreur" fait référence à l'erreur entre l'état idéal et l'approximation lorsqu'il s'agit d'un ordinateur quantique parfait (c'est-à-dire sans décohérence, sans erreur de porte).

— Nelimee
source

L'algorithme HHL avec une matrice 4 x 4 A peut être trop volumineux pour l'ordinateur IBM. J'ai essayé une version jouet plus petite de l'algorithme selon arXiv 1302.1210 link Résolution de systèmes d'équations linéaires

J'ai expliqué un peu ce circuit ici à stackexchange: /cs/76525/could-a-quantum-computer-perform-linear-algebra-faster-than-a-classical-computer/ 77036 # 77036

Malheureusement, ce n'est qu'une entrée 1 qubit avec une matrice A = 2 x 2, dans la réponse, un lien vers le circuit IBM est donné.

— Bram
source

Le problème avec l'implémentation HHL 4x4 n'est pas le nombre de qubits (7 qubits sont nécessaires) mais les taux d'erreur des portes quantiques et les temps de décohérence. Une implémentation d'un système 4x4 utilisant QISKit est disponible ici . L'implémentation suit arxiv.org/abs/1110.2232v2 .

— Nelimee

Grande mise en œuvre d'un HHL 4 x 4.

— Bram