5.1.2 Bit-Orakel

Dieser Ansatz funktioniert nicht nur für die logische AND\operatorname{AND}-Funktion, sondern für jede beliebige Funktion

f:{0,1}n{0,1}\displaystyle f\colon\{0,1\}^{n}\to\{0,1\}

die nn Bits als Eingabe erhält und ein einzelnes Bit ausgibt. Für jede solche Funktion können wir eine Operation auf (n+1)(n+1) Bits definieren:

[x1,,xn,y][x1,,xn,yf(x1,,xn)]\displaystyle[x_{1},\dots,x_{n},y]\mapsto[x_{1},\dots,x_{n},y\oplus f(x_{1},% \dots,x_{n})] (5.4)

für alle x1,,xn,y{0,1}x_{1},\dotsc,x_{n},y\in\{0,1\}. Genau wie Gl. 5.3 ist diese Operation ihr eigenes Inverse, zweimaliges anwenden verändert den Zustand also nicht.

Es ist beruhigend, dass wir jede Funktion f:{0,1}n{0,1}f:\{0,1\}^{n}\to\{0,1\} wie in Gl. 5.4 umkehrbar implementieren können. Zunächst einmal bedeutet das, dass jede Berechnung auf einem klassischen Computer so durchgeführt werden kann, dass die ursprüngliche Eingabe wiederhergestellt werden kann. Weiterhin können Berechnungen, die umkehrbar sind, auch auf Quantencomputern durchführen. Das bedeutet, dass Quantencomputer alles berechnen können was auch klassische Computer können! Außerdem können wir damit jede Funktion ff als Orakel auf einem Quantencomputer implementieren.

Lass uns einmal sehen, wie das funktioniert. Die Quantenversion der Operation aus Gl. 5.4 ist wie folgt definiert:

Uf|x1,,xn,y=|x1,,xn,yf(x1,,xn)U_{f}\left|x_{1},\dots,x_{n},y\right\rangle=\left|x_{1},\dots,x_{n},y\oplus f(% x_{1},\dots,x_{n})\right\rangle (5.5)

für alle x1,,xn,y{0,1}x_{1},\dotsc,x_{n},y\in\{0,1\}. Gl. 5.5 bestimmt dabei, wie UfU_{f} sich auf allen Basiszuständen von n+1n+1 Qubits verhält. Wie immer können wir diese Definition durch Linearität auf auf beliebige Zustände auf n+1n+1 Qubits erweitern. Da UfU_{f} einfach nur die Basiszustände permutiert, kannst du wie in 4.4 zeigen, dass es eine gültige Quantenoperation darstellt.

Wir nennen die Quantenoperation UfU_{f} aus Gl. 5.5 das Bit-Orakel für ff (wir könnten auch die Funktion aus Gl. 5.4 als klassisches Bit-Orakel bezeichnen, aber wir brauchen diesen Namen nicht). Die Bezeichnung ‘Orakel’ bedeutet einfach, dass sich das Anwenden dieser Operation so verhält, als würden wir ein allmächtiges Orakel bitten, uns den Wert der Funktion für jede beliebige Eingabe zu geben. Wir wissen nicht genau, wie das Orakel implementiert ist oder woher es die Antworten bekommt, wir werden nur zählen, wie viele Fragen wir an das Orakel stellen müssen, um eine gewisse Eigenschaft der Funktion ff herauszufinden. Viele interessante Algorithmische Probleme können so modelliert werden, wie wir im Rest der Quest sehen werden.

Das Konzept eines Orakels ist ein wenig wie das ‘Rate meine Zahl’-Spiel. Ein:e Freund:in von dir denkt sich eine Zahl aus und du fragst dann Fragen der Form “Ist deine Zahl x”? Darauf erhältst du dann entweder “Ja” oder “Nein” als Antwort. Mit anderen Worten stellt dein:e Freund:in eine Funktion dar, die “Nein” auf allen Eingaben außer einer einzigen (der Zahl, die festgelegt wurde) ausgibt. Jede Frage die du stellst gibt dir mehr Informationen über die Zahl. Du könntest dir zum Beispiel gedanken darüber machen, wie viele Fragen du stellen musst, um die Zahl zu finden. Und was wäre, wenn du deine Fragen an ein Quantenorakel UfU_{f} stellen könntest, anstelle an deine:n Freund:in? Könntest du die Lösung dann mit weniger Fragen finden? In dieser Woche wirst du mehrere interessante Beispiele kennenlernen, wo das tatsächlich der Fall ist!

Lass uns mal einige Beispiele für Bit-Orakel besprechen. Nehmen wir an, ff ist die AND-Funktion. Laut Gl. 5.1 können wir AND als Multiplikation modulo 2 interpretieren, da AND(x1,x2)=x1x2AND(x_{1},x_{2})=x_{1}x_{2}. Das entsprechende Bit-Orakel

UAND|a,b,c=|a,b,cab\displaystyle U_{\operatorname{AND}}\left|a,b,c\right\rangle=\left|a,b,c\oplus ab\right\rangle

ist nichts anderes als das Toffoli Gatter aus 4.4. Selbst für n=1n=1 und die Funktion f(x)=xf(x)=x, die einfach ihre Eingabe ausgibt, erhalten wir ein interessantes Ergebnis: für alle a,b{0,1}a,b\in\{0,1\} gilt dann

Uf|a,b=|a,ba.\displaystyle U_{f}\left|a,b\right\rangle=\left|a,b\oplus a\right\rangle.

Das entspricht einfach dem bekannten kontrolliertem-NOT-Gatter CNOT12\mathrm{CNOT}_{1\to 2} aus Gl. 3.64 in Abschnitt 3.2.4! Das Bit-Orakel bildet also mehrere interessante Quantenoperationen, die wir zuvor per Hand definiert hatten. In der folgenden Übung kannst du versuchen, alle anderen Ein-Bit-Orakel zu implementieren.

Übungsaufgabe 5.1 (Bit-Orakel für Ein-Bit-Funktionen).

Sei f:{0,1}{0,1}f:\{0,1\}\to\{0,1\} eine Funktion mit einem einzelnen Eingabe- und Ausgabe-Bit. Eine solche Funktion ist vollständig durch die Werte f(0),f(1){0,1}f(0),f(1)\in\{0,1\} definiert. Das sind zwei Bits, also gibt es genau vier solcher Funktionen. Wir haben gerade besprochen, wie man die das Bit-Orakel UfU_{f} für die Funktion f(x)=xf(x)=x implementiert. Kannst du die Bit-Orakel UfU_{f} für die anderen drei Funktionen in Quirky implementieren?

Lösung. Die anderen drei Funktionen sind f=NOTf=\mathrm{NOT} sowie die zwei konstanten Funktionen f(0)=f(1)=0f(0)=f(1)=0 und f(0)=f(1)=1f(0)=f(1)=1.
  • Für die NOT-Funktion gilt:

    UNOT|a,b=|a,bNOT(a)=|a,ba1=|a,NOT(ba),\displaystyle U_{\mathrm{NOT}}\left|a,b\right\rangle=\left|a,b\oplus\mathrm{% NOT}(a)\right\rangle=\left|a,b\oplus a\oplus 1\right\rangle=\left|a,\mathrm{% NOT}(b\oplus a)\right\rangle,

    was wie als Zusammensetzung einer kontrollierten-NOT-Operation und einer NOT-Operation auf dem zweiten Qubit geschrieben werden kann, also,

    UNOT=(INOT)CNOT12.\displaystyle U_{\mathrm{NOT}}=(I\otimes\mathrm{NOT})\,\mathrm{CNOT}_{1\to 2}.

    In Quirky sieht das dann so aus:

    [Uncaptioned image]

  • Für die Alles-Null-Funktion f(0)=f(1)=0f(0)=f(1)=0 gilt:

    Uf|a,b=|a,b,\displaystyle U_{f}\left|a,b\right\rangle=\left|a,b\right\rangle,

    also müssen wir gar nichts machen:

    [Uncaptioned image]

  • Für die Alles-Eins-Funktion f(0)=f(1)=1f(0)=f(1)=1 gilt:

    Uf|a,b=|a,b1=|a,NOT(b),\displaystyle U_{f}\left|a,b\right\rangle=\left|a,b\oplus 1\right\rangle=\left% |a,\mathrm{NOT}(b)\right\rangle,

    also müssen wir nur das zweite Qubit invertieren:

    [Uncaptioned image]