Erste Schritte ins Quantencomputing

Schwierigkeitsgrad: Anfänger
QPU-Zeitverbrauch: 11s

Willkommen, Hacker! Wir freuen uns, dich beim Workshop begrüßen zu dürfen. Das Hauptziel dieses einführenden Hands-on ist es, dich für deine Quantenreise vorzubereiten, indem wir dir 1) zeigen, wie du Qiskit installierst, 2) wie du ein IBM Cloud-Konto erstellst und api_key sowie crn vorbereitest, um einen echten Quantencomputer zu nutzen, 3) deinen ersten Quantum Circuit erstellst, 4) ein Quantenzustands-Quiz löst und 5) deine Circuits auf dem echten Quantencomputer ausführst und das Ergebnis darstellst.

1. Zunächst das Wichtigste: Qiskit

Was ist Qiskit

Das Qiskit SDK ist ein leistungsstarkes Software-Stack, das Entwicklern und Forschern hilft, die volle Leistungsfähigkeit von Quantencomputern im Utility-Maßstab und darüber hinaus zu nutzen. Im Kern steht das Qiskit SDK, ein Open-Source-Software-Development-Kit für die Arbeit mit Quantencomputern auf der Ebene erweiterter Quantum Circuits, Operatoren und Primitives. Das Qiskit SDK ermöglicht es jedem, optimale Leistung von echten Quantencomputern in der bevorzugten Computing-Umgebung zu erzielen.

Über das SDK hinaus umfasst Qiskit auch eine Reihe leistungsstarker Tools und Services wie den Qiskit Runtime Service, der optimierte Berechnungen auf IBM-Quantencomputern über die Cloud mithilfe von Primitives ermöglicht, die Fehlerminimierung verwalten. Der Qiskit Transpiler Service bietet modernste heuristische und KI-gestützte Methoden, die die Leistung bei gängigen Optimierungsaufgaben für Quantum Circuits verbessern.

Qiskit functions, ein Katalog von IBM- und Drittanbieter-Services, der es einfach macht, Workloads zu optimieren und Qiskit für industrielle Anwendungsfälle zu nutzen. Egal ob du ein Quantensoftware-Entwickler, ein Quantenexperimentator, ein Computerwissenschaftler bist oder einfach einsteigen möchtest – Qiskits modulares, flexibles Framework lässt dich auf der Abstraktionsebene arbeiten, die deinen Anforderungen am besten entspricht.

Qiskit ist für Erweiterbarkeit und Anpassung ausgelegt, sodass du branchenführende Leistung erzielen und neue Arten von Problemen angehen kannst. Eine leistungsstarke Codebasis bedeutet, dass ein Qiskit SDK schneller arbeitet, weniger Speicher verbraucht und bessere Ergebnisse als je zuvor liefert. Außerdem stellt dir Qiskit eine riesige Community von Nutzern und Entwicklern vor, die dich herzlich willkommen heißen und deine Fragen beantworten wollen. Erstmals im Jahr 2019 gestartet, ist das Qiskit-Advocate-Programm eine globale, community-zentrierte Initiative, die Fachleute und Enthusiasten des Quantencomputings aus der ganzen Welt rekrutiert. Im Laufe der Jahre sind Advocates zu anerkannten Führungspersönlichkeiten in der Quantum-Community geworden. Möchtest du die nächste Quantum-Führungspersönlichkeit sein? Zögere nicht, dich zu bewerben – hier

Qiskit installieren

Überprüfe zunächst, ob die Python-Version in deiner Umgebung python>=3.10 ist, um sicherzustellen, dass sie mit der neuesten Qiskit-Version kompatibel ist, die wir verwenden werden.

from platform import python_version

print(python_version())

Falls das nicht der Fall ist, kannst du es mit deinem bevorzugten Tool aktualisieren. Wenn du dir nicht sicher bist, wie das geht, sind einige empfohlene Optionen:

MacOS: Homebrew
Linux: sudo apt-get update

Eine detaillierte Anleitung zum Aktualisieren von Python je nach Betriebssystem findest du hier: How to update Python

Für weitere Informationen wirf einen Blick auf das QGSS (Qiskit Global Summer School) 2025 Wiki: https://github.com/qiskit-community/qgss-2025/wiki/Jupyter-Notebook-Environment-(Local-and-Online)

Du kannst deine Installation überprüfen, indem du die folgende Zelle ausführst. Wenn die Installation korrekt war, wird die Qiskit-Version zurückgegeben.

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit

%pip install 'qiskit[visualization]'
%pip install qiskit-ibm-runtime
%pip install qiskit-aer

import qiskit

print(f"Qiskit version: {qiskit.__version__}")

Fehlerbehebung

Falls die vorherige Zelle einen Fehler ausgelöst hat, kannst du Qiskit in einer virtuellen Umgebung installieren (zwei empfohlene Methoden folgen). Wenn keine Fehler aufgetreten sind, kannst du diese Zelle ignorieren und zur nächsten übergehen.

Wir schlagen zwei verschiedene Methoden vor, um eine virtuelle Umgebung für die Installation von Qiskit einzurichten.

Verwendung von venv, wie in der Qiskit-Installationsanleitung beschrieben.
Verwendung von conda, wie in diesem Video von Coding with Qiskit erklärt.

2. Dein IBM Cloud-Konto einrichten

Um einen echten Quantencomputer zu nutzen, benötigst du einen api key – das Hauptzugangsticket zur Cloud – und eine crn – ein Token, das dir deine Ressourcen bereitstellt, indem es dein Konto einrichtet.

Richte dein Konto wie folgt ein:

Gehe zur IBM Quantum® Platform.
Gehe zur oberen rechten Ecke (wie im obigen Bild gezeigt), erstelle deinen API-Token und kopiere ihn an einen sicheren Ort.
Ersetze in der nächsten Zelle deleteThisAndPasteYourAPIKeyHere durch deinen API-Schlüssel.
Gehe zur unteren linken Ecke (wie im obigen Bild gezeigt) und erstelle deine Instanz. Achte darauf, den Open Plan zu wählen.
Nachdem die Instanz erstellt wurde, kopiere den zugehörigen CRN-Code. Möglicherweise musst du die Seite aktualisieren, um die Instanz zu sehen.
Ersetze in der folgenden Zelle deleteThisAndPasteYourCRNHere durch deinen CRN-Code.

Weitere Informationen zum Einrichten deines IBM Cloud®-Kontos findest du in dieser Anleitung.

⚠️ Hinweis: Behandle deinen API-Schlüssel wie ein sicheres Passwort. Weitere Informationen zur Verwendung deines API-Schlüssels in sicheren und nicht vertrauenswürdigen Umgebungen findest du in der Cloud-Setup-Anleitung.

Wenn du Mitglied des IBM Partner Network University bist, verwende bitte die E-Mail-Adresse deiner Institution für deine IBM-ID, um den Partner-Vorteil zu erhalten.

from qiskit_ibm_runtime import QiskitRuntimeService

# Save your API key and crn and have access to the quantum computers
your_api_key = "deleteThisAndPasteYourAPIKeyHere"
your_crn = "deleteThisAndPasteYourCRNHere"

QiskitRuntimeService.save_account(
    channel="ibm_cloud",
    token=your_api_key,
    instance=your_crn,
    overwrite=True
)

# Check that the account has been saved properly
service = QiskitRuntimeService()
service.saved_accounts()

# See backends you can use
service.backends()

3. Dein erster Quantum Circuit

Quantum Circuits

Die grundlegende Einheit von Qiskit ist der Quantum Circuit, eine Reihe von Anweisungen, die ein Quantencomputer verwenden kann, um mit Quanteninformationsbits, auch bekannt als Qubits, zu arbeiten. Diese Qubits haben besondere Eigenschaften, die es Quantencomputern ermöglichen, Probleme anders anzugehen als dein Laptop oder iPhone. Qiskit entwickelt sich rasant – während du deine Quantum Circuits immer noch manuell entwerfen und entscheiden kannst, wie er ausgeführt werden soll (und es gibt viele gute Gründe dafür), bietet IBM Quantum auch Tools, die den Prozess vereinfachen. Zum Lernen werden wir einen sehr einfachen Circuit entwerfen und ihn auf einem Simulator ausführen.

Wir gehen diese Übersicht zügig durch, weil wir ehrlich gesagt Stunden damit verbringen könnten, nur die Grundlagen der Quanteninformation und -berechnung zu erklären. Tatsächlich hat IBM Quantum dies bereits getan und einen schriftlichen Kurs sowie eine Reihe von Videovorlesungen zu diesem Thema erstellt. Falls du eine Auffrischung brauchst, schau sie dir an!

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization import array_to_latex
from qiskit.visualization import plot_distribution

import numpy as np
from numpy import sqrt

Grundlegende Operationen auf Qubits und Messungen

Einzelne Qubit-Zustände aufschreiben

Beginnen wir damit, uns ein einzelnes Qubit anzusehen. Der Hauptunterschied zwischen einem klassischen Bit, das nur die Werte 0 und 1 annehmen kann, besteht darin, dass ein Quantenbit oder Qubit in den Zuständen $\vert0\rangle$ , $\vert1\rangle$ sowie in einer Linearkombination dieser beiden Zustände sein kann. Dieses Merkmal ist als Superposition bekannt und ermöglicht es uns, den allgemeinsten Zustand eines Qubits wie folgt zu schreiben:

$\vert\psi\rangle = \sqrt{1-p}\vert0\rangle + e^{i \phi} \sqrt{p} \vert1\rangle$

Wenn wir den Zustand dieses Qubits messen würden, fänden wir das Ergebnis $1$ mit Wahrscheinlichkeit $p$ und das Ergebnis $0$ mit Wahrscheinlichkeit $1-p$ . Wie du siehst, beträgt die Gesamtwahrscheinlichkeit $1$ , was bedeutet, dass wir tatsächlich entweder $0$ oder $1$ messen werden und keine anderen Ergebnisse existieren.

Zusätzlich zu $p$ hast du vielleicht noch einen weiteren Parameter oben bemerkt. Die Variable $\phi$ gibt die relative Quantenphase zwischen den beiden Zuständen $\vert0\rangle$ und $\vert1\rangle$ an. Wie wir später entdecken werden, ist diese relative Phase sehr wichtig. Für jetzt genügt es zu bemerken, dass die Quantenphase das ist, was Interferenz zwischen Quantenzuständen ermöglicht, was uns in die Lage versetzt, Quantenalgorithmen zur Lösung spezifischer Aufgaben zu schreiben.

Quantenzustände visualisieren

Wir visualisieren Quantenzustände in dieser Übung mit dem sogenannten qsphere. So sieht die qsphere für die Zustände $\vert0\rangle$ und $\vert1\rangle$ aus. Beachte, dass der oberste Teil der Kugel den Zustand $\vert0\rangle$ darstellt, während der unterste den Zustand $\vert1\rangle$ darstellt.

#visualize |0>
sv=Statevector([1, 0])
plot_state_qsphere(sv)

Du kannst dieselbe QSphere auch mithilfe eines Quantum Circuits erstellen. Der hier verwendete Statevector stammt vom Zustand $|0\rangle$ . In Qiskit wird das Qubit im Zustand $|0\rangle$ initialisiert. Versuche, den folgenden Circuit auszuführen, und schau, ob du dieselbe QSphere erhalten kannst.

qc1 = QuantumCircuit(1)
sv=Statevector(qc1)
plot_state_qsphere(sv)

Lass uns nun den Zustand $|1\rangle$ visualisieren. Es sollte keine Überraschung sein, dass der Superpositons-Zustand mit Quantenphase $\phi = 0$ und Wahrscheinlichkeit $p = 1/2$ (d.h. gleiche Wahrscheinlichkeit für 0 und 1) auf der qsphere mit zwei Punkten dargestellt wird. Beachte jedoch auch, dass die Größe der Kreise an den beiden Punkten kleiner ist als bei einfachem $\vert0\rangle$ und $\vert1\rangle$ oben. Das liegt daran, dass die Größe der Kreise proportional zur Messwahrscheinlichkeit ist, die sich nun halbiert hat.

#visualize 1/sqrt(2)|0> + 1/sqrt(2)|1>

sv=Statevector([1/sqrt(2), 1/sqrt(2)])
plot_state_qsphere(sv)

Im Fall von Superpositons-Zuständen, bei denen die Quantenphase ungleich null ist, ermöglicht uns die qsphere, diese Phase durch die Farbe des jeweiligen Flecks zu visualisieren. Zum Beispiel wird der Zustand mit $\phi = 90^\circ$ (Grad) und Wahrscheinlichkeit $p = 1/2$ in der qsphere unten gezeigt.

sv=Statevector([1/sqrt(2), 1/sqrt(2)*1j])
plot_state_qsphere(sv)

Qubits manipulieren

Qubits werden durch das Anwenden von Quantum Gates manipuliert. Lass uns einen Überblick über die verschiedenen Gates geben, die wir in den folgenden Übungen betrachten werden.

Beschreiben wir zunächst, wie wir den Wert von $p$ für unseren allgemeinen Quantenzustand ändern können. Dazu verwenden wir zwei Gates:

$X$ -Gate: Dieses Gate wechselt zwischen den beiden Zuständen $\vert0\rangle$ und $\vert1\rangle$ . Diese Operation ist dasselbe wie das klassische NOT-Gate. Daher wird das $X$ -Gate manchmal auch als Bit-Flip- oder NOT-Gate bezeichnet. Mathematisch ändert das $X$ -Gate $p$ auf $1-p$ , also insbesondere von 0 auf 1 und umgekehrt.
$H$ -Gate: Dieses Gate ermöglicht es uns, vom Zustand $\vert0\rangle$ in den Zustand $\frac{1}{\sqrt{2}}\left(\vert0\rangle + \vert1\rangle\right)$ zu wechseln. Dieser Zustand ist auch als $\vert+\rangle$ bekannt. Mathematisch bedeutet dies, von $p=0, \phi=0$ zu $p=1/2, \phi=0$ zu gehen. Da der Endzustand des Qubits eine Superposition von $\vert0\rangle$ und $\vert1\rangle$ ist, stellt das Hadamard-Gate eine echte Quantenoperation dar.

Beachte, dass beide Gates den Wert von $p$ geändert haben, aber nicht $\phi$ . Glücklicherweise ist es ganz einfach, die Wirkung dieser Gates zu visualisieren, indem man sich die folgende Abbildung ansieht.

Sobald wir den Zustand $\vert+\rangle$ haben, können wir dann die Quantenphase durch die Anwendung anderer Gates ändern. Zum Beispiel fügt ein $S$ -Gate eine Phase von $90$ Grad zu $\phi$ hinzu, während das $Z$ -Gate eine Phase von $180$ Grad zu $\phi$ hinzufügt. Um eine Phase von $90$ Grad zu subtrahieren, können wir das $S^\dagger$ -Gate anwenden, das als S-Dagger gelesen wird und häufig als sdg geschrieben wird. Schließlich gibt es ein $Y$ -Gate, das eine Folge von $Z$ - und $X$ -Gates anwendet.

Du kannst mit den Gates $X$ , $Y$ , $Z$ , $H$ , $S$ und $S^\dagger$ experimentieren, um dich mit den verschiedenen Operationen und ihrer Auswirkung auf den Zustand eines Qubits vertraut zu machen. Dazu kannst du den Circuit Composer besuchen und unser Circuit-Widget starten. Nachdem du den Circuit Composer besucht hast, wähle ein Gate aus, das auf ein Qubit angewendet werden soll, und dann das Qubit (in den ersten Beispielen ist das einzige Qubit Qubit 0). Beobachte, wie sich der entsprechende Zustand mit jedem Gate ändert, sowie die Beschreibung dieses Zustands. Es wird dir auch den Code bereitstellen, der den entsprechenden Quantum Circuit in Qiskit erstellt.

Wenn du mehr über die Beschreibung von Quantenzuständen, Pauli-Operatoren und andere Einzel-Qubit-Gates erfahren möchtest, sieh dir Quantum Information des Einzelsystems des Basics of Quantum Information Kurses von John Watrous an.

Übungen: Quantum Circuits mit Einzel-Qubit-Gates

Hier sind vier kleine Übungen, um verschiedene Zustände auf der qsphere zu erreichen. Du kannst sie entweder mit dem Circuit Composer lösen und den bereitgestellten Code in die entsprechenden Zellen kopieren, um die Quantum Circuits zu erstellen, oder du kannst direkt eine Kombination der folgenden Code-Zeilen in das Programm einfügen, um die verschiedenen Gates anzuwenden:

qc.x(0) # bit flip qc.y(0) # bit and phase flip qc.z(0) # phase flip qc.h(0) # superpostion qc.s(0) # quantum phase rotation by pi/2 (90 degrees) qc.sdg(0) # quantum phase rotation by -pi/2 (90 degrees)

Die '(0)' gibt an, dass wir dieses Gate auf Qubit 'q0' anwenden, das erste (und in diesem Fall einzige) Qubit.

Versuche, in jeder der folgenden Übungen den angegebenen Zustand auf der qsphere zu erreichen.

i) Beginnen wir mit einem Bit-Flip. Das Ziel ist es, den Zustand $\vert1\rangle$ ausgehend vom Zustand $\vert0\rangle$ zu erreichen.

def create_circuit():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

# check solution
qc2 = create_circuit()
state = Statevector(qc2)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

ii) Als nächstes erstellen wir eine Superposition. Das Ziel ist es, den Zustand $|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)$ zu erreichen.

def create_circuit2():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc3 = create_circuit2()
state = Statevector(qc3)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iii) Kombinieren wir diese beiden. Das Ziel ist es, den Zustand $|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)$ zu erreichen.

Kannst du die obigen beiden Aufgaben kombinieren, um auf die Lösung zu kommen?

def create_circuit3():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc4 = create_circuit3()
state = Statevector(qc4)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iv) Schließlich wenden wir uns den komplexen Zahlen zu. Das Ziel ist es, den Zustand $|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)$ zu erreichen

def create_circuit4():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc5 = create_circuit4()
state = Statevector(qc5)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

4. Quantum Quiz with Multi-Qubit Gates

Gut gemacht! Jetzt, da du die Single-Qubit Gates verstanden hast, schauen wir uns Gates an, die auf mehrere Qubits wirken. Hier wirst du gebeten, 4 Quanten-Zustand-Quizze zu loesen, indem du Single-Qubit Gates und Multi-Qubit Gates kombinierst. Die grundlegenden Gates fuer zwei Qubits sind:

qc.cx(c,t) # controlled-X (= CNOT) gate with control qubit c and target qubit t qc.cz(c,t) # controlled-Z gate with control qubit c and target qubit t qc.swap(a,b) # SWAP gate that swaps the states of qubit a and qubit b

Wenn du mehr über die verschiedenen Multi-Qubit Gates und ihre Beziehungen lesen möchtest, besuche Quantum Information über mehrere Systeme aus Johns Kurs Basics of Quantum Information.

Beachte, dass bei zwei Qubits ein allgemeiner Zustand die Form $a|00\rangle + b |01\rangle + c |10\rangle + d|11\rangle$ hat, wobei $a$ , $b$ , $c$ und $d$ komplexe Zahlen sind, deren Betragsquadrate die Wahrscheinlichkeit angeben, den jeweiligen Zustand zu messen; z.B. wäre $|a|^2$ die Wahrscheinlichkeit, bei beiden Qubits im Zustand '0' zu landen. Das bedeutet, wir können nun bis zu vier Punkte auf der QSphere haben.

Wir beginnen mit dem kanonischen Zwei-Qubit-Gate, dem controlled-NOT (auch CNOT oder CX) Gate. Hier ist, wie bei allen kontrollierten Zwei-Qubit-Gates, ein Qubit als "control" (Steuer-Qubit) und das andere als "target" (Ziel-Qubit) bezeichnet. Wenn das Control-Qubit im Zustand $|0\rangle$ ist, wendet es das Identitäts-Gate $I$ auf das Target an, d.h., es wird keine Operation durchgeführt. Wenn das Control-Qubit hingegen im Zustand $|1\rangle$ ist, wird ein X-Gate auf das Target-Qubit angewendet. Daher ist das CNOT-Gate mit beiden Qubits in einem der zwei klassischen Zustände $|0\rangle$ oder $|1\rangle$ auf klassische Operationen beschränkt.

Diese Situation ändert sich dramatisch, wenn wir zuerst ein Hadamard-Gate auf das Control-Qubit anwenden und es in den Superpositionszustand $|+\rangle$ bringen. Die Wirkung eines CNOT-Gates auf diesen nicht-klassischen Input kann stark verschränkte Zustände zwischen Control- und Target-Qubit erzeugen. Wenn das Target-Qubit anfänglich im Zustand $|0\rangle$ ist, wird der resultierende Zustand mit $|\Phi^+\rangle$ bezeichnet und ist einer der sogenannten Bell states.

i) Construct the Bell state $|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)$ .

Für diesen Zustand hätten wir die Wahrscheinlichkeit $\frac{1}{2}$ , "00" zu messen, und die Wahrscheinlichkeit $\frac{1}{2}$ , "11" zu messen. Daher sind die Messergebnisse beider Qubits perfekt korreliert.

def create_circuit5():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc6 = create_circuit5()
state = Statevector(qc6) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc6.draw(output='mpl') # we draw the circuit

Als nächstes versuche den Zustand perfekt anti-korrelierter Qubits zu erzeugen. Beachte das Minuszeichen hier, das die relative Phase zwischen den beiden Zuständen anzeigt.

ii) Construct the Bell state $\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)$ .

def create_circuit6():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc7 = create_circuit6()
state = Statevector(qc7) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc7.draw(output='mpl') # we draw the circuit

iii) Dir wird der Quantenschaltkreis gegeben, der in der folgenden Funktion beschrieben ist. Tausche die Zustände des ersten und zweiten Qubits aus, um diese QSphere zu erhalten.

def create_circuit7():
    qc = QuantumCircuit(2)
    qc.rx(np.pi/3,0)
    qc.x(1)
    return qc

qc8 = create_circuit7()

#
#
# FILL YOUR CODE IN HERE
#
#

state = Statevector(qc8) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc8.draw(output='mpl') # we draw the circuit

iv) Write a program from scratch that creates the GHZ state (on three qubits), $\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)$

def create_circuit8():
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    #
    return qc

qc9 = create_circuit8()

pub4 = (qc9)

state = Statevector(qc9) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc9.draw(output='mpl') # we draw the circuit

5. Run your circuit and see the measured result with a real quantum computer

Jetzt wissen wir, wie man einen Quantum Circuit aufbaut, um einen Zustandsvektor von Qubits zu manipulieren. Und es ist Zeit für den aufregendsten Teil: den Circuit ausführen und die Ausgabe sehen! Hier lernen wir die moderne und effektive Methode, unsere Circuits mit Qiskit auszuführen.

Ein Qiskit-Pattern ist ein allgemeines Framework, um domänenspezifische Probleme aufzugliedern und benötigte Fähigkeiten in Phasen zu kontextualisieren. Dies ermöglicht die nahtlose Kombinierbarkeit neuer Fähigkeiten, die von IBM Quantum-Forschenden (und anderen) entwickelt wurden, und ermöglicht eine Zukunft, in der Quantencomputing-Aufgaben von leistungsstarker heterogener (CPU/GPU/QPU) Computing-Infrastruktur durchgeführt werden.

Die vier Schritte eines Qiskit-Patterns sind wie folgt:

Map problem to quantum circuits and operators
Optimize for target hardware
Execute on target hardware
Post-process results

Wir haben gerade Step 1: Mapping abgeschlossen, indem wir Quantum Circuits aufgebaut haben, um den gewünschten Quantenzustand zu erzeugen. Lass uns nun die verbleibenden Schritte durchgehen, um die Ergebnisse zu sehen.

Optimize

Hier werden wir das Backend einstellen, um Circuits auszuführen – du kannst das least busy QPU unter deinen zugänglichen QPU-Gruppen auswählen oder einfach einen Simulator wählen, wenn du nicht genug verbleibende GPU-Zeit hast. Sobald du ein Backend ausgewählt hast, wird pass_manager deine Circuits in die nativen Gate-Sets des gewählten Backends transpilieren und für dich optimieren, um ein besseres Ergebnis zu erzielen. Du kannst pass_manager leicht deklarieren, indem du generate_preset_pass_manager verwendest und den optimization_level setzt, wobei eine höhere Zahl mehr Optimierungsschritte anzeigt.

Der nächste Schritt ist aufregend – wir werden den Quantum Circuit mit Qiskit Runtime ausführen!

Wir werden das mit den zwei Qiskit primitives tun:

Sampler nimmt Stichproben aus dem Ausgaberegister bei der Ausführung eines oder mehrerer Quantum Circuits. Seine Ausgabe sind Counts bei Einzel-Shot-Messungen.
Estimator berechnet den Erwartungswert eines oder mehrerer Observablen in Bezug auf die durch den Quantum Circuit erzeugten Zustände. Seine Ausgabe besteht aus den Erwartungswerten zusammen mit ihren Standardfehlern.

Hier verwenden wir Sampler, um unsere Circuits auszuführen. Die Code-Zelle unten zeigt dir, wie du zuerst ein Backend und einen Pass Manager dafür definierst. Dann wird measurement zu allen Circuits hinzugefügt und ein Array von Quantum Circuits (pub) erstellt, das an den Sampler übergeben wird.

backend=service.least_busy()
#backend=AerSimulator()

pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
sampler = Sampler(mode=backend)

pub = []
for qc in circ:
    qc.measure_all()
    pub.append(pm.run(qc))

Execute

Lass uns unsere Circuits ausführen. Falls es an der Cloud viele Warteschlangen gibt, gib die job_id aus und speichere sie zur späteren Verwendung, und überprüfe den job_status. Nachdem du siehst, dass sich der Job-Status auf Done geändert hat, rufe das Job-Ergebnis ab.

job = sampler.run(pub)
job_id = job.job_id()
print(job_id)
job.status()

job_retrived = service.job(job_id)
result = job.result()

Post-process

Der letzte Schritt besteht darin, die Visualisierung zu interpretieren, um die von uns erzeugten Quantenzustände zu verstehen. Bevor wir mehrere Grafiken erstellen, holen wir alle Counts aus allen Circuits. Dann erstellen wir 4 Plots, indem wir die Circuits kategorisieren.

result = job.result()
counts_all = [result[k].data.meas.get_counts() for k in range(9)]

The Single Qubit States

plot_distribution([counts_all[0], counts_all[1]], legend =['qc1', 'qc2'])

The Superpositioned One Qubit States

plot_distribution([counts_all[2], counts_all[3], counts_all[4]], legend =['qc3', 'qc4', 'qc5'])

Two Qubit States

plot_distribution([counts_all[5], counts_all[6], counts_all[7]],legend =['qc6', 'qc7', 'qc8'] )

Three Qubit States

plot_distribution(counts_all[8], legend=['qc9'])

Further challenge

Hast du Rauschen in den tatsächlichen Backend-Experimentergebnissen festgestellt? Das Entfernen von Qubit-Rauschen ist eines der aktiven Forschungsgebiete. Probiere Qiskit Runtime's various error mitigation and surpression options aus, um zu sehen, wie sich das Rauschen in den Ausführungsergebnissen verändert! (Hinweis) Diese Optionen ermöglichen mehr QPU-Zeit.

Additional Info

import qiskit, qiskit_ibm_runtime

print("Qiskit version:", qiskit.version.get_version_info())
print("Qiskit Runtime version:", qiskit_ibm_runtime.__version__)

Qiskit version: 2.1.1
Qiskit Runtime version: 0.40.1

Created by: Sophy Shin

Reviewed by: Nate Earnest-Noble

This is licensed under the Apache License, Version 2.0. You may obtain a copy of this license in the LICENSE file in the root directory of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this must retain this copyright notice, and modified files need to carry a notice indicating that they have been altered from the originals.

1. Zunächst das Wichtigste: Qiskit​

Was ist Qiskit​

Qiskit installieren​

Fehlerbehebung​

2. Dein IBM Cloud-Konto einrichten ​

3. Dein erster Quantum Circuit​

Quantum Circuits​

Grundlegende Operationen auf Qubits und Messungen​

Einzelne Qubit-Zustände aufschreiben​

Quantenzustände visualisieren​

Qubits manipulieren​

Übungen: Quantum Circuits mit Einzel-Qubit-Gates​

i) Beginnen wir mit einem Bit-Flip. Das Ziel ist es, den Zustand ∣1⟩\vert1\rangle∣1⟩ ausgehend vom Zustand ∣0⟩\vert0\rangle∣0⟩ zu erreichen.​

ii) Als nächstes erstellen wir eine Superposition. Das Ziel ist es, den Zustand ∣+⟩=12(∣0⟩+∣1⟩)|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)∣+⟩=2​1​(∣0⟩+∣1⟩) zu erreichen.​

iii) Kombinieren wir diese beiden. Das Ziel ist es, den Zustand ∣−⟩=12(∣0⟩−∣1⟩)|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)∣−⟩=2​1​(∣0⟩−∣1⟩) zu erreichen.​

iv) Schließlich wenden wir uns den komplexen Zahlen zu. Das Ziel ist es, den Zustand ∣↺⟩=12(∣0⟩−i∣1⟩)|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)∣↺⟩=2​1​(∣0⟩−i∣1⟩) zu erreichen​

4. Quantum Quiz with Multi-Qubit Gates​

i) Construct the Bell state ∣Φ+⟩=12(∣00⟩+∣11⟩)|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)∣Φ+⟩=2​1​(∣00⟩+∣11⟩).​

ii) Construct the Bell state ∣Ψ−⟩=12(∣01⟩−∣10⟩)\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)∣Ψ−⟩=2​1​(∣01⟩−∣10⟩).​

iii) Dir wird der Quantenschaltkreis gegeben, der in der folgenden Funktion beschrieben ist. Tausche die Zustände des ersten und zweiten Qubits aus, um diese QSphere zu erhalten.​

iv) Write a program from scratch that creates the GHZ state (on three qubits), ∣GHZ⟩=12(∣000⟩+∣111⟩)\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)∣GHZ⟩=2​1​(∣000⟩+∣111⟩)​

5. Run your circuit and see the measured result with a real quantum computer​

Optimize​

Execute​

Post-process​

Further challenge​

Additional Info​