Artikelformat

Hilft uns Quantencomputing, das Paradoxon von Schrödingers Katze zu verstehen?

cat

Quantencomputer wirken so wie die ersten Großrechner in den vierziger oder fünfziger Jahren: raumgroße Apparate, auf die nur eine kleine Anzahl von Experten Zugriff hat. Fast so wie das Orakel von Delphi mit seiner speziellen Kaste von Priestern. Anders als damals kann heute im Prinzip jeder diese Technologie über das Internet nutzen.

Beispielsweise bietet Microsoft Azure einen Zugriff verschiedenen Quantencomputer und hat mit Q# eine spezielle Programmiersprache für das Quantencomputing geschaffen. Weiterhin bietet Mircrosoft auch ein Onlinetutorial an, um die Sprache Q# zu lernen. Das hat mich neugierig gemacht.

So ganz einfach ist es leider nicht: Man braucht Kenntnisse in Linearer Algebra und komplexen Zahlen. Für mich waren das als Prüfungsthemen im Vordiplom, ebenso wie der Zusammenhang von komplexen Zahlen und trigonometrischen Funktionen. Im späteren Berufsleben musste ich dies alles jedoch nie anwenden.

Viele Jahrzehnte konnten wir Programmiersprachen noch diesen vier Paradigma klassifizieren:

  • Prozedural
  • Funktional
  • Objektorientiert
  • Deklarativ.

Für jeder dieser Paradigmen braucht man eine bestimmte Denkweise, um Probleme damit lösen zu können.

Für das Quantencomputing braucht man nochmal eine ganz andere Denkweise. So kann man zwar die Lösung eines Problems in einem Quantenzustand im Prinzip schon vorliegend haben, muss dann jedoch noch Tricks anwenden um an die Lösung heranzukommen und schafft es auch nicht unbedingt mit hundertprozentiger Wahrscheinlichkeit.

Und was war mit der Katze?

Das erstem mal habe ich hier 1997 über das Gedankenexperiment mit Schrödingers Katze geschrieben. Versuchen wir mal dieses Experiment mit einem einfaches Model in Q# auszudrücken.

Ein radioaktives Partikel einspricht einem QuBit. Es ist mit einer Wahrscheinlichkeit von 50% zerfallen. Bevor wir nicht durch eine Messung einen Zustand erzwingen befindet es sich jedoch noch in einem Quantenzustand. In Q# können wir das so ausdrücken:

Message("Preparing radioactive atom");
use radioactiveAtom = Qubit();
H(radioactiveAtom);

Der H-Operator bringt unser QuBit in einen Quantenzustand, der einer Wahrscheinlichkeitswelle entspricht. Es gibt weitere Operatoren, z. B. können wir dem Y-Operator die Phase dieser Welle „ins Imaginäre“ manipulieren. Hier brauchen wir das jedoch nicht.

Unsere Katze modelliere ich mit einen weiteren Qubit. Ich kann jetzt den Quantenzustand des Partikels mit dem der Katze “verschränken”. Dazu dient der CNOT() Operator. Das dies so einfach geht ist schon beeindruckend.

use cat = Qubit();
SetQubitState(One, cat); // the cat is alive
CNOT(radioactiveAtom, cat); // entangle the life of the cat with the radioactive atom

Auf diesen Modellierungsgrad haben wir leider noch keinen besonderen Erkenntnisgewinn: Wenn wir den Zustand des Partikels kennen, kennen wir den Zustand der Katze, und umgekehrt. Ja, klar.
Im Q# kann ich eine Messung mit dem M()-Operator durchführen und erhalte so wieder klassische Bits:

let isFired = M(radioactiveAtom); // measure the atom
let isCatAlive = M(cat);

Wir können jetzt mit den Q# Simulator den Quantenzustand simulieren, bevor die Messung einen der beiden Zustände erzwingt, Das geht natürlich nur mit relativ wenigen QuBits weil der Rechenaufwand exponentiell steigt. Aber immerhin erlaubt es uns die Quantenzustände und ihre Wellenfunktionen anzuzeigen. Hierzu rufen wir einfach die Funktion „DumpMachine()“ auf. Eine Ausgabe kann so aussehen:

Preparing radioactive Atom
Radioactive Atom after applying H:
|0⟩      0.707107 +  0.000000 i  ==     ***********          [ 0.500000 ]     --- [  0.00000 rad ]
|1⟩      0.707107 +  0.000000 i  ==     ***********          [ 0.500000 ]     --- [  0.00000 rad ]
Radioactive Atom and Cat after entangle them:
|0⟩      0.000000 +  0.000000 i  ==                          [ 0.000000 ]                   
|1⟩      0.707107 +  0.000000 i  ==     ***********          [ 0.500000 ]     --- [  0.00000 rad ]
|2⟩      0.707107 +  0.000000 i  ==     ***********          [ 0.500000 ]     --- [  0.00000 rad ]
|3⟩      0.000000 +  0.000000 i  ==                          [ 0.000000 ]                   
Radioactive Atom and Cat after the measurement:
|0⟩      0.000000 +  0.000000 i  ==                          [ 0.000000 ]                   
|1⟩      0.000000 +  0.000000 i  ==                          [ 0.000000 ]                   
|2⟩      1.000000 +  0.000000 i  ==     ******************** [ 1.000000 ]     --- [  0.00000 rad ]
|3⟩      0.000000 +  0.000000 i  ==                          [ 0.000000 ]

Das Atom und das Leben der Katzen sind zunächst im Quantenzustand, mit Wahrscheinlichkeit von 50% eins oder null. Die Ausgabe zeigt die Wahrscheinlichkeiten der Zustände, einmal als Darstellung mit reellen und imaginären Anteil, einmal als Darstellung mit dem Winkel der Phase in Radiant-Darstellung.
Im Beispiel hat die Katze das Experiment überlebt, das Qubit ist mit Wahrscheinlichkeit von 1 im Zustand „One“.

So interessant es ist, erlaubt es uns leider keine Antwort auf die Frage, was mit unserer Katze passiert während ihr Leben an dem Quantenzustand des Atoms hängt. Speziell sehen wir nicht, ob es irgendeine Art von Interferenzmuster zwischen einer toten Katzen und einer lebendigen Katze gibt. Dazu ist mein Model wohl zu einfach, so bleibt der Zustand von Schrödingers Katze weiter rätselhaft.

Trotzdem: wer keine Angst vor der nötigen Mathematik hat, dem kann ich das Experimentieren mit Quantencomputing empfehlen. Die Simulationsausgabe ist ein schönes Hilfsmittel um die Quantenzustände zu verstehen. Das Entwickeln von echten Quantenalgorithmen sehe als ziemlich schwierig an. Ein wenig Zeit wird es wohl auch noch brauchen bevor die ersten echten Anwendungen die Welt verändern werden.

Autor: Karsten Meier

Weil ich gerne Probleme löse bin ich Informatiker geworden. Ich berate und Konzeptionieren und entwickle mit fast allem, was einen Prozessor hat.

Hinterlassen Sie eine Antwort