In 15 min zum ersten Quantenprogramm

Obwohl Google kürzlich das Erreichen der sogenannten "Quantum Supremacy" verkündet hat, ist der Hype um den Quantencomputer aktuell noch eher überschaubar. Das mag damit zu tun haben, das zwar annähernd jeder IT-Interessierte bereits etwas über Quantencomputer gehört oder gelesen hat, wirklich verstanden haben es jedoch vermutlich die wenigsten. Vom Erstellen von Quantenprogrammen gar nicht zu reden. Wie einfach zumindest der grundlegende Einstieg in die Quatenprogrammierung in rund 10 min gelingen kann, möchte ich in diesem Post beschreiben.

Zugegeben, auch mir ging es bis vor kurzem so: mir war nicht klar, wie sich mit Qubits (Quantenbits), die 0 und 1 zur gleichen Zeit sein können, Probleme effizient lösen lassen sollen. Die meisten Erklärungen, die sich online zu diesem Thema finden, sind nämlich entweder zu oberflächlich oder gleich so mathematisch, dass es keinen Spaß mehr macht, sie nachzuvollziehen. Zudem gibt es noch recht wenige deutschsprachige Ressourcen, die vielleicht gerade bei diesem komplexen Gebiet den Einstieg erleichtern könnten (wobei natürlich jeder Informatiker auch mit Englisch klarkommen sollte).

Daher möchte ich mit diesem Blog-Post (und evtl. noch folgenden) meine persönliche Reise beim Entdecken der "Quantenrechnerei" dokumentieren und hoffentlich dem ein oder anderen Leser ein wenig das Verständnis und den Einstieg erleichtern. Hier bewegen wir uns nämlich tatsächlich im "Neuland" und können erleben, wie die Grundlagen einer Technologie geschaffen werden, die die Möglichkeiten von Computern grundlegend verändern könnte.

Als sehr hilfreich habe ich dabei empfunden, mit Quantencomputern tatsächlich zu programmieren. Moment... mit echten Quantencomputern? Sind die innendrin nicht "colder than outer space" und entsprechend super-teuer? Ja, das sind sie, und noch gibt es leider keine Quantencomputer für den Hobbykeller, doch wer ein wenig seinen Pioniergeist ausleben möchte, kann das tatsächlich: bspw. IBM bietet online einen Zugriff auf seine Quanten-Hardware an.

Das ist, wie es dieser Youtuber so schön formuliert, ein wenig so, als würde uns die NASA einen ihrer Mars-Rover steuern lassen. (Falls es letztere Idee je gegeben haben sollte, sie wurde vermutlich wegen dieses Vorfalls wieder verworfen. ;-) Daher empfiehlt es sich natürlich, einen entsprechenden Simulator (wie Qiskit) zu installieren (wie in diesem Video erklärt), um Quantenprogramme lokal testen zu können und die echten Quantencomputer nur mit sinnvollen Programmen zu behelligen.

Grundlagen

Zum Einstieg in die Quantenprogrammierung, seien einige Hintergründe in aller Kürze erläutert. Wie bereits erwähnt, verwenden Quantencomputer sogenannte Qubits, die entweder 0 oder 1 oder auch beides zugleich sein können. Dieser letztgenannte Zustand nennt sich Superposition und ist einer der Gründe, der Quantencomputer leistungsfähiger als herkömmliche Computer machen soll. 0 bzw. 1 werden bei Qubits übrigens wie folgt in der sogenannten Dirac-Noation geschrieben: |0> bzw. |1>. Das hat damit zu tun, dass die Zustände von Qubits üblicherweise Vektoren sind, muss aber hier erst einmal nicht im Detail interessieren.

Als Qubits kommen in der Praxis verschiedene Arten von Elementarteilchen in Frage, also etwa Elektronen, Protonen oder auch Photonen. Werden bspw. Elektronen verwendet, können diese über Mikrowellen manipuliert und ausgelesen werden. Einen guten ersten Eindruck dazu vermittelt z.B. dieses Video aus Australien.

Wird ein Qubit in Superposition versetzt, also im Fall eines Elektrons mit Mikrowellen "angeregt", befindet es sich gleichzeitig sowohl im Zustand 0 als auch im Zustand 1. Sobald es ausgelesen wird, muss es sich allerdings für einen Wert entscheiden: wir erinnern uns an die bedauernswerte Katze des Herrn Schrödinger (die übrigens kürzlich tot aufgefunden wurde ;-), mit deren Hilfe sich dieses physikalische Phänomen veranschaulichen lässt. Oder auch an den Doppelspaltversuch im Physik-Unterricht, wo selbst einzelne Photonen durch beide Spalten gleichzeitig zu gehen scheinen und mit sich selbst wechselwirken können.

Wie sich auf Basis einer solchen Überlagerung programmieren lassen soll, war (und ist z.T. noch immer) für mich das erste große Fragezeichen beim Verständnis der Quantencomputer.

Grafische Programmierung in der Cloud

Doch Moment, könnten wir uns diese Unbestimmt zum Einstieg nicht einfach für etwas zunutze machen, was herkömmliche Computer nicht besonders gut beherrschen? Nämlich gerade das Erzeugen von Zufallszahlen? Mit dem folgenden Zufallszahlengenerator bei der IBM Quantum Experience möchte ich nun endlich ein erstes Quantenprogramm, und wie es auf echter Quanten-Hardware ausgeführt werden kann, beschreiben.

Nach Anmeldung und Login bei IBM klicken wir dazu auf "Create a circuit", also das Erstellen eines Quantenschaltkreises, und sollten etwa folgenden Bildschirm zu sehen bekommen:

Der rechte untere Bereich zeigt uns die aktuell zur Verfügung stehenden Qubits sowie darunter eine klassische Datenleitung, die zum Auslesen der Qubits verwendet werden kann. Die bunten Kästchen darüber sind die Quantengatter (quantum gates) mit deren Hilfe die Qubits manipuliert werden können. Und ja, hier ist echter Pioniergeist gefragt, Quantencomputer werden aktuell tatsächlich auf dem Bit- oder besser gesagt Qubit-Level programmiert.

Quantengatter sind im Prinzip sehr ähnlich zu herkömmlichen Gattern, die (wir erinnern uns) zur Verarbeitung von herkömmlichen Bits verwendet werden. Allerdings gibt es einige der gewohnten Gatter (wie AND oder OR) in der Quantenwelt erst einmal nicht. Das hat damit zu tun, dass in der Quantenwelt Qubits nicht einfach so kopiert werden könne und alle elementaren Operationen eindeutig umkehrbar sein müssen. Das bedeutet, dass aus dem Ergebnis die Eingabe wieder herstellbar sein muss, was bspw. bei OR, wo sowohl 10, 01 und auch 11 das Ergebnis 1 liefern, offensichtlich nicht der Fall ist.

Doch zurück zu unserem Zufallszahlen-Generator: für diesen müssen wir mindestens ein Quantenbit in Superposition versetzen, das geht ganz einfach z.B. mit dem sogenannten Hadamard- oder kurz auch H-Gate, das im Bild an erster Stelle der blauen Kästchen steht. Dieses ziehen wir per Drag-und-Drop auf die Linie neben einem der Qubits:

Im Bild wird also das erste Qubit q[0], das sich anfangs im Zustand |0> befindet, in Superposition versetzt (und ist nun sowohl |0> als auch |1>). Nun können wir noch das letzte schwarze Kästchen zum Messen bzw. Auslesen des Qubits auf die Linie setzten und haben damit quasi unser "Quanten-Hello-World" erstellt:

Das Messgatter legt den Wert des Quantenbits auf das entsprechende klassische Bit, dabei wird, wie bereits gesagt, die Superposition des Qubits zerstört, es muss sich fest für einen Wert (also entweder 0 oder 1) "entscheiden". Die in den Schaltkreis gesetzten Gatter können übrigens angeklickt und dann ggf. mit dem kleinen "x" in der rechten oberen Ecke wieder gelöscht werden.

Um nun unseren "Quanten-Hello-World-Moment" zu erleben (das dauert bis hierhin übrigens keine 10 min) , müssen wir noch oben rechts im Bild zunächst auf "Unsaved changes" und danach auf "Run" klicken. Sodann können wir aus einem Simulator sowie einer Reihe echter Quantencomputer das gewünschte Backend zum Ausführen wählen und angeben, wie oft das Programm ausgeführt werden soll. Da sich mit nur einer Ausführung keine Zufallsverteilung wird feststellen lassen, sollten wir hier mindestens 1024 auswählen. Einige Augenblicke später erscheint dann im unteren Fensterbereich ein Link zum Ergebnis der Berechnung:

Den Trommelwirbel müssen wir uns leider selbst dazu denken (oder hier abspielen): nach einem Klick auf den gezeigten Link finden wir im unteren Bereich der folgenden Seite in etwa das folgende Bild:

Dieses zeigt uns an, bei wie vielen der 1024 Aufrufe das Qubit q[0] zufällig mit einer 0 und bei wie vielen es mit einer 1 ausgelesen wurde. Im Bild siegt die 1 mit einem knappen Vorsprung gegenüber der 0.

Um bspw. eine Zufallszahl zwischen 0 und 7 generieren zu können, erweitern wir das Programm leicht wie folgt...

... und führen es 4096 mal auf einem der echten IBM-Quantencomputer (z.B. ibmq_ourense) aus. Das liefert uns die folgende Verteilung von Zufallszahlen (Trommelwirbel nicht vergessen):

Dabei wird q[0] ganz wie in einer normalen Darstellung eines Bit-Strings auf das am weitesten rechts stehende Bit übertragen, nicht wie die obige Anordnung der Measurement-Gates implizieren könnte, auf das am weitesten links stehende.

Mit einem Klick auf das kleine Code-Symbol am linken Rand (das </>) können wir uns übrigens auch den zugehörigen QASM-Code (Quantenassembler-Code) in Textform anzeigen lassen.

Dieser sollte mehr oder weniger selbsterklärend sein, zusammenfassend sei hier aber noch einmal der Programmaufbau beschrieben: wir legen ein Quantenregister mit 5 Qubits sowie ein klassisches Register mit 5 Bits an, versetzen die ersten drei Qubits mit dem Hadamard-Gate in Superposition und erzwingen durch jeweils eine Messung eine Festlegung der Qubits auf |0> oder |1>.

Lokal programmieren

Wer, wie im bereits genannten Video beschrieben, Qiskit installiert hat, kann ein identisches Programm auch ganz einfach lokal anlegen und ausführen: dazu müssen wir ein neues Jupyter Notebook für Python3 erstellen und folgenden Python-Code eingeben:

  from qiskit import *

  qr = QuantumRegister(3)
  cr = ClassicalRegister(3)

  circuit = QuantumCircuit(qr, cr)

  circuit.h(qr[0])
  circuit.h(qr[1])
  circuit.h(qr[2])

  circuit.measure(qr, cr)
 

  circuit.draw(output='mpl')

Ein Druck auf Shift + Return führt diesen Code-Schnipsel aus und zeichnet die drei Qubits sowie das klassische Register ähnlich zum vorherigen Bild aus dem Browser:

Ohne den Parameter beim draw-Aufruf erscheint übrigens eine ebenfalls brauchbare "ASCII-Art"-Darstellung des Quantenschaltkreises. Um das Quantenprogramm selbst ausführen zu können, wird auch lokal wieder ein Simulator benötigt, dessen Ergebnisse wir mit print ausgeben können:

  simulator = Aer.get_backend('qasm_simulator')

  result = execute(circuit, backend = simulator, shots = 1024).result()

  print(result.get_counts()) 

Dies ergibt bei meinem Durchlauf folgende Ausgabe:

  {'110': 120, '000': 131, '101': 114, '111': 133, 

   '010': 120, '011': 137, '100': 130, '001': 139}

Auch ein Plotten der Ergebnisse analog zur Cloud-Variante ist mit einem weiteren Import problemlos möglich...

  from qiskit.tools.visualization import plot_histogram
  plot_histogram(result.get_counts())

...  und ergibt das folgende Bild:

Qiskit to Quantum Computer

Abschließend sei noch erläutert, wie der Aufruf des echten Quantencomputers bei IBM von Qiskit aus funktioniert (Voraussetzung ist das Hinterlegen eines Access-Tokens in Qiskit wie im Video von vorhin gezeigt), es erfordert an für sich nur den Austausch des Backends gegen einen echten Quantencomputer, wie der folgende Code-Schnipsel illustriert:

  from qiskit.tools.monitor import job_monitor

  IBMQ.load_account()
  provider = IBMQ.get_provider('ibm-q')

  qcomputer = provider.get_backend('ibmq_ourense')

  job = execute(circuit, backend = qcomputer, shots = 1024)
  job_monitor(job)
  result = job.result()

  plot_histogram(result.get_counts())

Der Job-Monitor wird hier genutzt, um den Status der Job-Verarbeitung angezeigt bekommen zu können, da die Verarbeitung je nach Auslastung des gewählten Quantencomputers einige Augenblicke in Anspruch nehmen kann. Hat schließlich alles erfolgreich geklappt, erhalten wir abermals ein bereits vertraut wirkendes Histogramm:

Dies gezeigten Beispiele sollten reichen, um einen ersten Eindruck und hoffentlich ein besseres initiales Verständnis der Quantenrechnerei zu bekommen, auch wenn das Generieren von Zufallszahlen noch kein wirklich hilfreicher Algorithmus war. Immerhin haben wir in aller Kürze einen Quantencomputer bei IBM grafisch "programmiert" und auch lokal über Qiskit Quantencode erstellt, der sich zudem leicht in die IBM-Cloud hochladen und dort ausführen lässt.

Ich hoffe, Sie haben auch ein wenig Geschmack an der "Zukunft der Computer" gefunden, ich jedenfalls werde versuchen, weiter in diese spannende Welt einzutauchen und, so es meine Zeit zulässt, auch noch weitere Artikel zu posten. Ich freue mich auch, Sie wieder als interessierten Leser begrüßen zu dürfen.

Weitere Ressourcen:

• Qiskit Textbook 
• Qiskit Docs
• Qiskit API Docs (mögliche Bausteine eines Quantenschaltkreises)