Algorytm kwantowy dla liniowych układów równań (HHL09): Krok 2 - Przygotowanie stanów początkowych

^{To kontynuacja algorytmu kwantowego dla liniowych układów równań (HHL09): Krok 2 - Co to jest ?$|\Psi_0\rangle$}

W artykule: Algorytm kwantowy dla liniowych układów równań (Harrow, Hassidim i Lloyd, 2009) nie podano szczegółów rzeczywistej implementacji algorytmu. To , jak dokładnie tworzone są stany i , jest swego rodzaju „ czarną skrzynką ” (patrz strony 2-3).$|\Psi_0\rangle$$|b\rangle$

i

gdzie to stan początkowy rejestru zegara, a to stan początkowy rejestru wejściowego.$|\Psi_0\rangle$$|b\rangle$

(Powiedz) Chcę wykonać ich algorytm na komputerze kwantowym IBM qubit. $16$Chcę rozwiązać pewne równanie gdzie to macierz hermitowska z prawdziwymi wpisami, a to wektor kolumnowy z prawdziwymi wpisami.$\mathbf{Ax=b}$$\mathbf{A}$$4\times 4$$\mathbf{b}$$4\times 1$

Weźmy przykład:

i

Biorąc pod uwagę wymiary i , powinniśmy potrzebować kubity dla rejestru wejściowego i kolejne kubitów dla rejestru zegara, zakładając, że chcemy, aby wartości własne były reprezentowane z dokładnością i dokładnością do bitów dla wartości własnych (zostało to wcześniej omówione tutaj ). Tak więc w tym celu będzie potrzebnych ogółem kubitów (dodatkowy kubit to ancilla).$\mathbf{A}$$\mathbf{b}$$\lceil{\log_2 4\rceil}=2$$6$$90\%$$3$$2+6+1=9$$1$

Pytania:

1. Korzystając z tych informacji, czy można utworzyć początkowe stany i w wersji qubit IBM ?$|\Psi_0\rangle$$|b\rangle$$16$

2. Jeśli uważasz, że jest zbyt duży, aby go zaimplementować na komputerach kwantowych IBM, możesz nawet pokazać przykład przygotowania stanu początkowego dla macierzy Hermitian (lub po prostu podać odniesienie do takiego przykład).$4\times 4$$2\times 2$$\mathbf{A}$

Chcę po prostu uzyskać ogólne pojęcie o tym, czy można to zrobić (tj. Czy jest to możliwe) na komputerze kwantowym IBM 16-qubit i do tego, które bramy będą konieczne. Jeśli nie jest to komputer kwantowy IBM 16-qubit, czy można użyć symulatora QISKit do odtworzenia stanu początkowego i w algorytmie HHL? Czy jest jakaś inna lepsza alternatywa, aby to zrobić?$|\Psi_0\rangle$$|b\rangle$

Nie można utworzyć stanów początkowych $\left| \Psi_0\right>$ i $\left|b\right>$w wersji kubitów IBM 16. Z drugiej strony możliwe jest ich przybliżenie z arbitralnie niskim błędem ^1, ponieważ bramki zaimplementowane przez układy IBM oferują taką możliwość.

Tutaj pytasz o 2 różne stany kwantowe:

1. $\left| b \right>$wcale nie jest ograniczony. Stan$\left| b \right>$ jest reprezentowany przez wektor $N$ liczby zespolone, które mogą być dowolne (o ile wektor ma jednolitą normę).
2. $\left| \Psi_0 \right>$ może być postrzegany jako szczególny przypadek $\left| b \right>$, gdzie współczynniki $b_i$ są bardziej ograniczone.

Dzięki tej analizie można zastosować dowolną metodę tworzenia $\left|b\right>$ można również użyć do tworzenia $\left| \Psi_0 \right>$. Z drugiej strony, jak$\left| \Psi_0 \right>$ jest bardziej ograniczony, możemy mieć nadzieję, że istnieją wydajniejsze algorytmy do produkcji $\left| \Psi_0 \right>$.

Użyteczny do $\left|b\right>$ i $\left|\Psi_0\right>$: W oparciu o syntezę układów logiki kwantowej (Shende, Bullock i Markov, 2006) zestaw QISKit Python SDK implementuje ogólną metodę inicjowania dowolnego stanu kwantowego.

Użyteczny do $\left|\Psi_0\right>$: Tworzenie superpozycji, które odpowiadają efektywnie integrowalnym rozkładom prawdopodobieństwa (Grover i Rudolph, 2002), przedstawia szybko algorytm do inicjalizacji stanu, którego amplitudy reprezentują rozkład prawdopodobieństwa z uwzględnieniem niektórych ograniczeń. Te ograniczenia są przestrzegane$\left|\Psi_0\right>$zgodnie z algorytmem kwantowym rozwiązywania liniowych układów równań (Harrow, Hassidim i Lloyd, 2009) , ostatni wiersz strony 5.

Dla implementacji w QISKit, oto próbka inicjalizacji danego stanu kwantowego:

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)

¹ Tutaj „błąd” odnosi się do błędu między stanem idealnym a przybliżeniem w przypadku idealnego komputera kwantowego (tj. Bez dekoherencji, bez błędu bramki).

Algorytm HHL z macierzą 4 x 4 A może być zbyt duży dla komputera IBM. Wypróbowałem mniejszą zabawkową wersję algorytmu zgodnie z arXiv 1302.1210 link Układy rozwiązywania równań liniowych

Wyjaśniłem trochę o tym obwodzie tutaj na stackexchange: /cs/76525/could-a-quantum-computer-perform-linear-algebra-faster-than-a-classical-computer/ 77036 # 77036

Niestety jest to tylko 1 qubit wejściowy z macierzą A = 2 x 2, w odpowiedzi podano link do obwodu IBM.