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

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?

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^\dagger\otimes U_2^\dagger),$$ $C$$|\psi\rangle=(U_1\otimes U_2)|1\rangle\otimes(|0\rangle-|1\rangle)/\sqrt{2}$$U_1$$U_2$$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$

$$\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)$$ $\omega=e^{\pm i\pi/4}$$|\psi\rangle=(U_1\otimes U_2)(|01\rangle\pm|10\rangle)/\sqrt{2}$

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

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