Quantenschaltkreise programmieren

Übersicht

Sekundarstufe

Physik, Mathematik, Informatik, Technik

Deutsch

Zusammenfassung

Dieses Tutorial stellt zwei Möglichkeiten vor Quantenschaltkreise zu programmieren: visuelles Programmieren und coden in Qiskit. Sie lernen, wie Sie einfache Quantenschaltkreise auf Simulatoren oder echten Quantencomputern erstellen, visualisieren und ausführen, mit einer schrittweisen Anleitung für die Plattformen IBM Quantum und IQM. Der Schwerpunkt liegt auf praxisorientiertem Experimentieren, das für den Einsatz im Unterricht und in der Lehrerfortbildung geeignet ist.

Autoren: Christian Datzko (CH), Jörg Gutschank (DE)

Dieses Tutorial ist Teil des Unterrichtsmaterials Quantencomputing im MINT-Unterricht

Quantenschaltkreise visuell programmieren

Quantenschaltkreise können programmiert werden, indem die entsprechenden Quantengatter einfach per Drag-and-Drop in ein dafür vorgesehenes Feld gezogen und dort abgelegt werden.

Im Fall des IBM Quantum Composer werden Gatter aus einer Auswahl oben links in das Arbeitsfeld in der Mitte des Bildschirms gezogen. Die Anzahl der Qubits sowie der klassischen Bits (Register) für den Quantenschaltkreis kann unter <Edit>–<Manage Registers>festgelegt werden. Die Wahrscheinlichkeitsverteilung und der Zustand des Systems werden am unteren Rand des Bildschirms angezeigt, und Exportoptionen – beispielsweise nach Qiskit – stehen auf der rechten Seite zur Verfügung. Sie können Ihren Schaltkreis auf einem echten IBM-Quantencomputer ausführen, wenn Sie über ein Konto verfügen und angemeldet sind. Andernfalls können Sie den integrierten Simulator verwenden, der den Schaltkreis auf einem klassischen Computer ausführt und zeigt, wie sich ein ideales, rauschfreies Quantensystem verhalten würde.

© Screenshot Composer IBM Quantum Platform

Qiskit: Programme auf Quantencomputern ausführen

Quantencomputer können auch mit Qiskit programmiert werden. Qiskit ist ein Open-Source-Framework für Quantencomputing, das es ermöglicht, einen Quantenschaltkreis durch das Schreiben von Codezeilen zu erstellen, anstatt auf visuelle Elemente in einer grafischen Benutzeroberfläche zu klicken. Letzteres kann bei größeren Quantenschaltkreisen unübersichtlich werden. Qiskit stellt Python-Module bereit, die auf nahezu jedem Computer verwendet werden können. Qiskit bietet nicht nur ein Framework für den Zugriff auf echte Quantencomputer, sondern auch auf Simulatoren und weitere nützliche Werkzeuge wie die Erstellung von Grafiken.

Je nach Anbieter unterscheiden sich die Zugangswege zu echter Quantenhardware leicht. Im Folgenden finden Sie Informationen dazu, wie Sie auf Quantencomputer bei IQM, einem finnischen Anbieter von Quantenhardware, sowie bei IBM Quantum zugreifen können.

Obwohl eine dedizierte Python-Umgebung nicht zwingend erforderlich ist, um ein einzelnes Beispiel auszuführen, verwenden wir Miniforge, um eine klar definierte und isolierte Python-Umgebung zu erstellen. Dies ist besonders hilfreich für Lehrkräfte, die sowohl mit den Backends von IBM Quantum als auch von IQM experimentieren möchten, da diese Plattformen mitunter unterschiedliche Python-Versionen oder Paketabhängigkeiten voraussetzen.

Mit Qiskit auf die Quantencomputer-Hardware von IQM zugreifen

Miniforge installieren um eine klar definierte Python Umgebung zu erstellen.
https://conda-forge.org/miniforge/
Erstellen Sie eine Pything-Umgebung mit der Python-Version 3.11 (sic!)^[2] mit dem Namen iqm (zum Beispiel) and aktivieren Sie diese:
```
conda create --name iqm python=3.11
conda activate iqm
```
Installieren Sie die IQM-Client-Software, die auch Qiskitbenthält:
```
pip install "iqm-client[qiskit]"
```

Beachten Sie die doppelten Anführungszeichen, ohne die die Installation auf einer Unix- oder Linux-Shell wie zsh oder bash nicht funktioniert!

Es kann auch sinnvoll sein, zusätzlich die Python-Pakete numpy, scipy, matplotlib, pylatexenc, und qiskit-aer zu installieren:

pip install numpy scipy matplotlib pylatexenc qiskit-aer

Erstellen Sie über den folgenden Link ein Benutzerkonto bei IQM:
https://resonance.meetiqm.com/sign-up/scienceonstage
Navigieren Sie zu ihrem Profil und erstellen und kopieren Sie von dort Ihr API token.
Führen Sie die Datei connection_test_iqm.py aus (Datei herunterladen)
```
python connection_test_iqm.py
```

Wenn Sie nach ihrem API-Token gefragt werden, geben Sie ihn in die Befehlszeile ein und drücke auf die Eingabetaste. Die Antwort IQM backend zeigt Ihnen, dass Sie sich erfolgreich mit IQM verbunden haben. Falls bevorzugt, kann der API token auch im Vorfeld gespeichert werden (z.B. als Umgebungsvariable), so dass er nicht jedes Mal neu eingegeben werden muss. Wie das gemacht wird, wird am Ende dieses Tutorial vorgestellt. .

Optional: Führen Sie die Datei 1plus1_iqm.py aus.(Datei herunterladen)
```
python 1plus1_iqm.py
```

Dieses Programm verwendet einen Quantencomputer, um eins und eins zu addieren. Lassen Sie Ihre Schüler*innen überlegen, ob es eine gute Idee ist, dafür einen Quantencomputer zu verwenden.

Optional: Installieren Sie die grafische Benutzeroberfläche Visual Studio Code. (https://code.visualstudio.com)

Die oben beschriebene Prozedur ist eine minimale Installation, die auf fast jedem Computer mit Internetverbindung funktioniert. Man kann natürlich auch andere Frontends oder sogenannte Jupyter Notebooks verwenden.

Zugriff auf Quantencomputer bei IBM Quantum

Miniforge installieren, um eine klar definierte Python Umgebung zu erstellen.
https://conda-forge.org/miniforge/
Erstellen Sie eine Python-Umgebung mit dem Namen ibm (zum Beispiel) und aktivieren diese:
```
conda create --name ibm python
conda activate ibm
```
Installiere Sie Qiskit (siehe auch https://quantum.cloud.ibm.com/docs/en/guides/install-qiskit ):
```
pip install qiskit
pip install qiskit-ibm-runtime
```
Es kann auch sinnvoll sein, zusätzlich die Python-Pakete jupyter, numpy, scipy, matplotlib und pylatexenc zu installieren (falls nicht schon automatisch geschehen).
Erstellen Sie über den folgenden Link ein Benutzerkonto bei IBM:
https://quantum.cloud.ibm.com/docs/en/guides/cloud-setup
Hinweis: Wenn Ihre Schüler*innen dauerhafte Benutzerkonten bekommen sollen, für die nicht nach einer kurzen Testphase Kreditkartennummern an IBM weitergegeben werden müssen, benötigen Sie und jede*r Schüler*in einen sogenannten IBM Cloud Feature Code vor der Erstellung des Benutzerkontos. Einen solchen Code erhalten Sie nur mit einer E-Mail-Adresse einer akademischen Einrichtung. Im Zweifelsfall verwenden Sie ein Testkonto mit einer separaten E-Mail-Adresse oder bitten Sie IBM im Voraus um Hilfe.
Erstelle und kopieren Sie Ihren API token:
https://cloud.ibm.com/iam/apikeys
Kopieren Sie Ihren Token unbedingt direkt nach der Erstellung. Der Token besteht aus 44 Zeichen. Wenn Sie ihn erst später kopieren, sind von den 44 nur noch 43 Zeichen übrig!
Kopieren Sie Ihre instance (beginnt mit crn:):
https://quantum.cloud.ibm.com/instances
Führe Sie die Datei connection_test_ibm.py aus (Datei herunterladen)
```
python connection_test_ibm.py
```
Wenn Sie nach dem API-Token gefragt werden, geben SIe ihn in die Befehlszeile ein und drücken Enter. Genauso geben Sie Ihre "instance" ein, wenn Sie danach gefragt werden. Eine Antwort beginnend mit ibm_ zeigt, dass Sie sich erfolgreich mit IBM verbunden hast.
Optional: Führen Sie die Datei 1plus1_ibm.py aus (Datei herunterladen)
```
python 1plus1_ibm.py
```
Dieses Programm verwendet einen Quantencomputer, um eins und eins zu addieren. Lassen Sie Ihre Schüler*innen überlegen, ob es eine gute Idee ist, dafür einen Quantencomputer zu verwenden.
Optional: Installieren Sie die grafische Benutzeroberfläche Visual Studio Code (https://code.visualstudio.com).

Erstellen eines einfachen Quantenschaltkreises

Um einen einfachen Quantenschaltkreis zu erstellen, müssen drei Schritte ausgeführt werden: das Vorbereiten und Initialisieren des Systems, das Zusammensetzen des Quantenschaltkreises sowie das Optimieren und Ausführen des Quantenschaltkreises.

In den folgenden Beispielen wird dieselbe grundlegende Quantenoperation in zwei verschiedenen Programmierumgebungen verwendet: ein auf ein einzelnes Qubit angewendetes Pauli‑X‑Gatter. Obwohl der Code in den jeweiligen Fällen unterschiedlich aussieht, beschreibt er dieselbe zugrunde liegende Operation. Unterschiede in Bezeichnungen, Befehlen oder der Struktur sind häufig eher eine Frage der Notation oder des Programmierstils als ein Unterschied in der quantenmechanischen Funktionalität.

Beispiel mit IQM Beispiel mit IQM


import os
import getpass
from qiskit import transpile
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from iqm.qiskit_iqm import IQMProvider

token = getpass.getpass("input IQM API Token: ")
os.environ["IQM_TOKEN"] = token

provider = IQMProvider(
    url="https://resonance.meetiqm.com/",
    # quantum_computer="sirius"
    # quantum_computer="garnet"
    quantum_computer="emerald"
)

backend = provider.get_backend()

qubit_register = QuantumRegister(4, 'q')
bit_register = ClassicalRegister(2, 'c')
qcirc = QuantumCircuit(qubit_register, bit_register)

# setting the input values:
# applying Pauli-X to set a=1
qcirc.x(qubit_register[0])
# applying Pauli-X to set b=1
qcirc.x(qubit_register[1])

# applying quantum gates:
# Toffoli gate
qcirc.ccx(qubit_register[0], qubit_register[1], qubit_register[3])
# CNOT
qcirc.cx(qubit_register[0], qubit_register[1])
# Toffoli
qcirc.ccx(qubit_register[1], qubit_register[2], qubit_register[3])
# CNOT
qcirc.cx(qubit_register[1], qubit_register[2])

# measure qubits 2 and 3
qcirc.measure(qubit_register[2], bit_register[0])
qcirc.measure(qubit_register[3], bit_register[1])

qcirc_transpiled = transpile(qcirc, backend)
job = backend.run(qcirc_transpiled, shots=1024)

print("job id: ", job.job_id())

result = job.result()
counts = result.get_counts()

print(
    "1 + 1 was measured 1024 times. The results are displayed as a binary number followed by the absolute frequency of the respective result."
)
print(counts)

Beispiel mit IBM Quantum Beispiel mit IBM Quantum

# Create a quantum circuit
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
# Optimise the quantum circuit
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
# Access IBM Quantum
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler

service = QiskitRuntimeService(channel="ibm_quantum", token="Insert your API token here, see Profile Settings -> API token")
# Choose the least busy quantum computer as backend
backend = service.least_busy(operational=True, simulator=False)
# Create a sampler, that will run the job on the chosen backend
sampler = Sampler(backend)
# Create a pass manager that will optimise the quantum circuit for the chosen backend; optimisation level 3 is the highest possible level. Lower levels are easier to understand but produce less accurateresults
passmanager = generate_preset_pass_manager(3, backend=backend)

# One quantum register is required.
quantum_registers = QuantumRegister(1, 'q')
# One classical register is required.
classical_registers = ClassicalRegister(1, 'c')
# Both registers are added to the quantum circuit.
circuit = QuantumCircuit(quantum_registers, classical_registers)
# The Pauli-X gate is applied to the quantum register.
circuit.x(quantum_registers[0])
# A measurement is performed on the quantum register and the result is “delivered” to the classical register.
circuit.measure(quantum_registers[0], classical_registers[0])

# Create the optimised quantum circuit
optimized_circuit = passmanager.run(circuit)

# Add the quantum circuit as a job to the job queue
job = sampler.run([optimized_circuit], shots=1000)
# Print the Job ID
print("job id:", job.job_id())
# Wait for the results; this can take some time, but the results will also be available on the IBM Quantum platform if the job is interrupted
result = job.result()
print(result[0].data.c.get_counts())

Der obige Code enthält einen sogenannten Transpiler, der den Quantenschaltkreis optimiert. Dies ist notwendig, da reale Quantencomputer nicht immer alle gewünschten Gatter bereitstellen. Einige Optimierungen verringern zudem das Rauschen des Quantenschaltkreises und führen zu besseren Ergebnissen.

Verschiedene Möglichkeiten zur visuellen Darstellung von Quantenschaltkreisen mit Qiskit

Neben der Ausführung von Quantenschaltkreisen bietet Qiskit auch die Möglichkeit, Quantenschaltkreise in anderen Darstellungsformen anzuzeigen. So kann ein Quantenschaltkreis beispielsweise statt ausgeführt zu werden als Text, als LaTeX‑Quellcode oder als Bilddatei (Pixelgrafik oder Vektorgrafik) visualisiert werden. Weitere Formate finden sich unter: https://docs.quantum.ibm.com/api/qiskit/qiskit.visualization.circuit_drawer

Code für verschiedene Visualisierungen Code für verschiedene Visualisierungen

# Import register:
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
# For output in LaTeX or as an image:
from qiskit.visualization import circuit_drawer
# For output as a matrix:
from qiskit.quantum_info import Operator
# Prepare the qubits:
quantum_registers = QuantumRegister(1, 'q')
# Prepare the bits:
classical_registers = ClassicalRegister(1, 'c')
# Create a quantum circuit:
circuit = QuantumCircuit(quantum_registers, classical_registers)
# Add a measurement:
circuit.measure(quantum_registers[0], classical_registers[0])
# Output as text:
print("The quantum circuit:")
print(circuit)
print("----------")
# Output in LaTeX:
print("The quantum circuit in LaTeX code:")
circuit_image = circuit_drawer(circuit, output="latex_source")
print(circuit_image)
print("----------")
# Output as image:
print("The quantum circuit as an image, saved as Example.png and Example.svg.")
circuit_image = circuit_drawer(circuit, output="mpl")
circuit_image.savefig("Example.png") # saved as pixel graphics
circuit_image.savefig("Example.svg") # saved as vector graphics
print("----------")

Code zur Matrixdarstellung Code zur Matrixdarstellung

Ein Quantenschaltkreis kann auch als Matrix dargestellt werden, die auf ein oder mehrere Qubits angewendet wird, welche als Vektoren (oder Kets) repräsentiert sind. Diese Darstellung erlaubt es jedoch nicht, Messungen einzubeziehen. Messungen lassen den Quantenzustand irreversibel kollabieren und liefern zufällige klassische Ergebnisse.

Das folgende Beispiel zeigt einen Quantenschaltkreis mit einem Hadamard‑Gatter.

# Prepare the qubits:
quantum_registers = QuantumRegister(1, 'q')
# Prepare the bits:
classical_registers = ClassicalRegister(1, 'c')
# Create a quantum circuit:
circuit = QuantumCircuit(quantum_registers, classical_registers)
circuit.h(quantum_registers[0])
# Matrix output as text
print("The matrix is (text):")
circuit_operator = Operator.from_circuit(circuit)
print(circuit_operator.draw("text"))
print("----------")
# Matrix output
print("The matrix is (LaTeX code):")
circuit_operator = Operator.from_circuit(circuit)
print(circuit_operator.draw("latex_source"))

Referenzen und Quellen Referenzen und Quellen

IQM ist nur mit Python 3.11 kompatibel
https://docs.quantum.ibm.com/migration-guides/local-simulators
https://quantum.ibm.com/composer/
https://conda-forge.org/miniforge/

Unterrichtsmaterialien

Zusatzmaterialien Zusatzmaterialien

connection_test_ibm.py connection_test_iqm.py 1plus1_ibm.py 1plus1_iqm.py

Diese Seite teilen