Przykładowy algorytm kwantowy, przydatny do demonstracji języków

9

Szukam algorytmu kwantowego, którego mogę użyć do zademonstrowania składni różnych języków kwantowych. Moje pytanie jest podobne do tego , jednak dla mnie „dobre” oznacza:

To, co robi, można opisać w 1-2 akapitach i powinno być łatwe do zrozumienia.
Powinien wykorzystywać więcej elementów „świata programowania kwantowego” (mam na myśli, że algorytm powinien wykorzystywać niektóre klasyczne stałe, pomiary, warunki, rejestry q, operatory itp., Jak najwięcej).
Algorytm powinien być mały (maksymalnie 15-25 linii pseudokodu).

Przydatne algorytmy są często zbyt długie / trudne, ale algorytm Deutscha nie wykorzystuje tak wielu elementów. Czy ktoś może zasugerować mi algorytm demo?

algorithm resource-request programming

— klenium
źródło

Czy wymagasz również, aby był to „algorytm” z klasycznym wejściem i klasycznym wyjściem oraz wyraźną korzyścią / różnicą w działaniu równoważnego klasycznego algorytmu?

— DaftWullie

@DaftWullie Nie są wymagane. Parametry operatora lub stała inicjalizacja klasyczna mogą reprezentować dla mnie „dane wejściowe”, a jeśli to konieczne, podam format wyjściowy. To nie musi być wyjątkowe. Nacisk kładziony jest na składnię języków, opis służy jedynie do sprawdzenia, czy kody w różnych językach są takie same. Znaczenie algorytmu jest nieistotne.

— klenium

Witamy w Quantum Computing SE! Wystarczy sprawdzić, czy twoje kryteria dobrej odpowiedzi stanowią najwięcej elementów w najkrótszym pseudo-kodzie?

— Mithrandir24601

1

@ Mithrandir24601 Thanks! Tak, jakoś tak.

— klenium

3

Sugeruję spojrzenie na protokoły szacowania wartości własnej / wektora własnego. Istnieje duża elastyczność, dzięki której problem jest tak łatwy lub trudny, jak chcesz.

Zacznij od wybrania dwóch parametrów, i . Chcesz zaprojektować qubit unitary, który ma wartości własne w postaci dla liczb całkowitych . Upewnij się, że przynajmniej jedna z tych wartości własnych jest unikalna i nazwij ją . Upewnij się także, że prosty stan produktu, powiedzmy , ma niezerowe nakładanie się z wektorem własnym wartości własnej . $n$ $k$ $n$ $U$ $e^{-2\pi iq/2^k}$ $q$ $\omega$ $|0\rangle^{\otimes n}$ $\omega$

Celem byłoby zaimplementowanie w tym celu algorytmu szacowania faz, otrzymaniu wartości i zadania polegającego na wygenerowaniu wektora który jest wektorem własnym odpowiadającym wartości własnej . Zasadniczo będzie to obwód kubitów (chyba że potrzebujesz ancillas do wdrożenia kontrolowanego- ). $k$ $|\psi\rangle$ $\omega$ $n+k$ $U$

Działa to w następujący sposób:

utworzenie dwóch rejestrów, z których jeden qubitach, a drugi z qubitach. ( wykorzystanie rejestrów kwantowych ) $k$ $n$

każdy kubit jest inicjowany w stanie . ( inicjalizacja rejestrów kwantowych ) $|0\rangle$

nałóż Hadamard na każdy kubit w pierwszym rejestrze ( bramki na pojedynczy kubit )

z qubit pierwszym rejestrze, zastosuj kontrolowany - , celując w drugi rejestr ( bramki kontrolowane wieloma kubitami ) $r$ $U^{2^{r}}$

zastosuj odwrotną transformatę Fouriera do pierwszego rejestru i zmierz każdy kubit pierwszego rejestru w sposób standardowy. Można je łączyć, realizując półklasyczną transformację Fouriera . ( pomiar i przekazywanie danych klasycznych )

dla poprawnego wyniku pomiaru drugi rejestr jest w pożądanym stanie . $|\psi\rangle$

Dla uproszczenia możesz wybrać , , więc potrzebujesz macierzy z wartościami własnymi . czegoś takiego jak gdzie oznacza kontrolowane NIE. Jest tylko jeden wektor własny z wartością własną -1, którym jest , a ty zadzierać z wyborem i aby zbadać implementację przy użyciu rozkładu w kategoriach uniwersalnego zestawu bramek (prawdopodobnie to jako problem wstępny). Następnie kontrolowany - $n=2$ $k=1$ $4\times 4$ $\pm 1$

(U_{1} \otimes U_{2}) C (U_{1}^{†} \otimes U_{2}^{†}),

$(U_1\otimes U_2)C(U_1^\dagger\otimes U_2^\dagger),$

C

$C$

| ψ ⟩ = (U_{1} \otimes U_{2}) | 1 ⟩ \otimes (| 0 ⟩ - | 1 ⟩) / \sqrt{2}

$|\psi\rangle=(U_1\otimes U_2)|1\rangle\otimes(|0\rangle-|1\rangle)/\sqrt{2}$

U_{1}

$U_1$

U_{2}

$U_2$

U

$U$

U

$U$ można go łatwo wdrożyć, zastępując bramę kontrolowany-NIE bramą kontrolowanego-NIE-Toffoli. Wreszcie odwrotna transformata Fouriera jest tylko bramą Hadamarda.

Dla czegoś nieco bardziej złożonego, wstaw i zamień na pierwiastek kwadratowy bramki wymiany, z i . $k=3$ $C$

(\begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & \frac{1}{\sqrt{2}} & \frac{i}{\sqrt{2}} & 0 \\ 0 & \frac{i}{\sqrt{2}} & \frac{1}{\sqrt{2}} & 0 \\ 0 & 0 & 0 & 1 \end{array})

$\left( \begin{array}{cccc} 1 & 0 & 0 & 0 \\ 0 & \frac{1}{\sqrt{2}} & \frac{i}{\sqrt{2}} & 0 \\ 0 & \frac{i}{\sqrt{2}} & \frac{1}{\sqrt{2}} & 0 \\ 0 & 0 & 0 & 1 \\ \end{array} \right)$

ω = e^{\pm i π / 4}

$\omega=e^{\pm i\pi/4}$

| ψ ⟩ = (U_{1} \otimes U_{2}) (| 01 ⟩ \pm | 10 ⟩) / \sqrt{2}

$|\psi\rangle=(U_1\otimes U_2)(|01\rangle\pm|10\rangle)/\sqrt{2}$

— DaftWullie
źródło

3

Wygląda na to, że chcesz kwantowego „Hello World”. Najprostszą wersją kwantową byłoby zapisanie binarnie zakodowanej wersji tekstu Hello Worldw rejestrze kubitów. Wymagałoby to jednak około 100 kubitów i byłoby dłuższe niż górny limit długości kodu.

Napiszmy więc krótszy fragment tekstu. Napiszmy ;), potrzebujemy łańcucha bitów o długości 16. W szczególności, używając kodowania ASCII

;)  =  00111011 00101001

Korzystając z QISKit, możesz to zrobić przy użyciu następującego kodu.

from qiskit import QuantumProgram
import Qconfig

qp = QuantumProgram()
qp.set_api(Qconfig.APItoken, Qconfig.config["url"]) # set the APIToken and API url

# set up registers and program
qr = qp.create_quantum_register('qr', 16)
cr = qp.create_classical_register('cr', 16)
qc = qp.create_circuit('smiley_writer', [qr], [cr])

# rightmost eight (qu)bits have ')' = 00101001
qc.x(qr[0])
qc.x(qr[3])
qc.x(qr[5])

# second eight (qu)bits have 00111011
# these differ only on the rightmost two bits
qc.x(qr[9])
qc.x(qr[8])
qc.x(qr[11])
qc.x(qr[12])
qc.x(qr[13])

# measure
for j in range(16):
    qc.measure(qr[j], cr[j])

# run and get results
results = qp.execute(["smiley_writer"], backend='ibmqx5', shots=1024)
stats = results.get_counts("smiley_writer")

Oczywiście nie jest to bardzo kwantowe. Możesz zamiast tego nałożyć superpozycję dwóch różnych emotikonów. Najłatwiejszym przykładem jest nałożenie;) 8), ponieważ ciągi bitów dla nich różnią się tylko qubitami 8 i 9.

;)  =  00111011 00101001
8)  =  00111000 00101001

Możesz więc po prostu zamienić linie

qc.x(qr[9])
qc.x(qr[8])

z powyższego za pomocą

qc.h(qr[9]) # create superposition on 9
qc.cx(qr[9],qr[8]) # spread it to 8 with a cnot

Hadamard tworzy superpozycję 0i 1, a węzeł zamienia się w superpozycję 00i 11na dwóch kubitach. Jest to jedyna wymagana superpozycja dla ;)i 8).

Jeśli chcesz zobaczyć faktyczną implementację tego, można go znaleźć w tutorialu QISKit (pełne ujawnienie: zostało napisane przeze mnie).

— James Wootton
źródło

Dostaję 404 za ten link. Czy plik został przeniesiony w inne miejsce?

— klenium

Wygląda na to, że samouczek został właśnie zaktualizowany. Zmieniłem link, więc powinien już działać.

— James Wootton

1

Proponuję (idealny) 1-bitowy generator liczb losowych. Jest to prawie banalnie łatwe:

Zaczynasz z pojedynczym kubitem w zwykłym stanie początkowym . Następnie zastosujesz bramę Hadamarda która wytwarza równe nałożenie i . Na koniec mierzysz ten kubit, aby uzyskać 0 lub 1, każdy z 50% prawdopodobieństwem. $\left|0\right>$ $H$ $\left|0\right>$ $\left|1\right>$

— piramidy
źródło