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


9

To kontynuacja algorytmu kwantowego dla liniowych układów równań (HHL09): Krok 2 - Co to jest ?|Ψ0


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).|Ψ0|b

|Ψ0=2Tτ=0T1sinπ(τ+12)T|τ

i

|b=1Nbi|i

gdzie to stan początkowy rejestru zegara, a to stan początkowy rejestru wejściowego.|Ψ0|b

(Powiedz) Chcę wykonać ich algorytm na komputerze kwantowym IBM qubit. 16Chcę rozwiązać pewne równanie gdzie to macierz hermitowska z prawdziwymi wpisami, a to wektor kolumnowy z prawdziwymi wpisami.Ax=bA4×4b4×1

Weźmy przykład:

A=[1234215635174671]

i

b=[1234]

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).Ablog24=2690%32+6+1=91

Pytania:

  1. Korzystając z tych informacji, czy można utworzyć początkowe stany i w wersji qubit IBM ?|Ψ0|b16

  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×42×2A

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ć?|Ψ0|b


1
O ile wiem, IBM nie może wykonywać HHL, ponieważ wymaga robienia rzeczy w superpozycji różnych czasów, ale nie byłbym zaskoczony, jeśli się mylę. @James Woottoon może lepiej znać odpowiedź.
user1271772

@ user1271772 Też tak myślałem, ale jestem trochę sceptyczny, ponieważ ktoś powiedział mi na czacie , że symulował HHL dla4×4po tym , na IBM.
Sanchayan Dutta

Cóż, może wystarczy ci rys. 4 z artykułu Yudong Cao (ten, który połączyłeś).
user1271772

@ user1271772 Tak, ale niestety, to działałoby tylko dla tej konkretnej matrycy. Szukam ogólnej techniki, dla której prawdopodobnie powinienem bardziej dokładnie przeczytać ten artykuł.
Sanchayan Dutta

Jak powiedział John Watrous w jednym ze swoich komentarzy do pytania, w którym ktoś prosił o konkretny obwód, „prosisz ludzi, aby wykonali żmudną, ale koncepcyjnie nieciekawą pracę”. Yudong był studentem inżynierii na studiach licencjackich, kiedy tworzył te obwody. Nie miał więcej treningu niż ty (w rzeczywistości na podstawie twojego szybkiego postępu, prawdopodobnie wiesz więcej na temat obliczeń kwantowych niż w momencie pisania tego artykułu). Jeśli mógłby zrobić ten obwód, powinieneś być w stanie wykonać odpowiedni obwód dla każdego przykładu HHL, który jest przed tobą.
user1271772

Odpowiedzi:


3

Nie można utworzyć stanów początkowych |Ψ0 i |bw 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. |bwcale nie jest ograniczony. Stan|b jest reprezentowany przez wektor N liczby zespolone, które mogą być dowolne (o ile wektor ma jednolitą normę).
  2. |Ψ0 może być postrzegany jako szczególny przypadek |b, gdzie współczynniki bi są bardziej ograniczone.

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

Użyteczny do |b i |Ψ0: 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 |Ψ0: 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|Ψ0zgodnie 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)

1 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).


0

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.


Problem z implementacją HHL 4x4 nie polega na liczbie kubitów (potrzebne jest 7 kubitów), ale na wskaźnikach błędu bramek kwantowych i czasach dekoherencji. Implementacja systemu 4x4 z wykorzystaniem QISKit jest dostępna tutaj . Implementacja następuje po arxiv.org/abs/1110.2232v2 .
Nelimee,

Świetne wdrożenie HHL 4 x 4.
Bram
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.