Ausführen von Quantensimulationen mit dem QDKPython Paket

Das MicrosoftQuantum Development Kit (QDK) Python Paket enthält lokale Quantensimulatoren, mit denen Sie Quantenprogramme testen und entwickeln können. In diesem Artikel wird erläutert, wie die Simulatoren installiert werden und Q#-, OpenQASM-, Qiskit- und QIR-Programme in Python oder Jupyter Notebook ausgeführt werden.

Das QDKPython Paket enthält vier primäre Simulatoren:

• Sparse-Simulator
• Stabilisator-Simulator
• GPU Simulator
• CPU Simulator

Weitere Informationen zu den QDK Quantensimulatoren finden Sie in der QDKÜbersicht über Quantensimulatoren.

Informationen zum direkten Ausführen von QDK- oder QDK-Programmen in der -Erweiterung für Visual Studio Code (VS Code) finden Sie unter Q#.

Voraussetzungen

Um den Jupyter Notebook Beispielen in diesem Artikel zu folgen, installieren Sie die folgenden Tools:

• Eine Python Umgebung mit Python 3.10 oder höher und Pip
• Die neueste Version von Visual Studio Code (VS Code)
• Die neuesten Versionen der Python Erweiterung und Jupyter-Erweiterung in VS Code

Installieren der Simulatoren

Um die Quantensimulatoren in Python und Jupyter Notebook zu verwenden, installieren Sie die neueste Version des qdkPython Pakets mit dem Extra jupyter:

pip install --upgrade "qdk[jupyter]"

Die Simulatoren benötigen das jupyter Extra nicht, aber das Extra fügt das qdk.widgets Modul hinzu, um Simulationsergebnisse in Jupyter Notebook zu visualisieren.

Wählen Sie einen Simulator basierend auf dem quantenprogrammierungsframework und der Python verwendeten API aus.

Rufen Sie den Sparse-Simulator auf

Der sparse Simulator unterstützt Q#, OpenQASMund Qiskit Programme. In dieser Tabelle wird gezeigt, wie 10 Durchläufe mit dem qdk Paket in den einzelnen Frameworks ausgeführt werden.

Führen Sie beispielsweise die folgenden Schritte aus, um das Bell-Paarprogramm Q# in einem Jupyter-Notizbuch in VS Code auszuführen:

1. Wählen Sie in VS Code Ansicht> aus.

2. Geben Sie Erstellen: Neues Jupyter-Notizbuch ein. Eine leere Notizbuchdatei wird auf einer neuen Registerkarte geöffnet.

3. Importieren Sie in der ersten Zelle das qsharp Modul aus dem qdk Paket.

   from qdk import qsharp
   

4. Verwenden Sie in einer neuen Zelle den %%qsharp magischen Befehl, um den Q# Code zu schreiben.

   %%qsharp
   
   operation Main() : (Result, Result) {
       use (q1, q2) = (Qubit(), Qubit());
       PrepareBellPair(q1, q2);
       (MResetZ(q1), MResetZ(q2))
   }
   
   operation PrepareBellPair(q1 : Qubit, q2 : Qubit) : Unit {
       H(q1);
       CNOT(q1, q2);
   }
   

5. Erstellen einer neuen Zelle. Um das Q# Programm auf dem sparse Simulator auszuführen, rufen Sie die run Funktion aus dem qsharp Modul auf, und geben Sie die Anzahl der Aufnahmen an.

   qsharp.run("Main()", shots=10)
   

Rufen Sie den Stabilisierungssimulator auf

Der Stabilisator-Simulator führt breite, Clifford-dominierte Schaltkreise effizient aus. Stabilisierungsverzweigung unterstützt auch eine begrenzte Anzahl von nicht-Clifford-Operationen, z. B. $T$- und $T^\dagger$-Tore sowie Drehungen mit beliebigen Winkeln Pauli. Da die Anzahl der Verzweigungen exponentiell mit der Anzahl der nicht-Clifford-Operationen wachsen kann, verwenden Sie einen Vollzustandssimulator für Schaltkreise mit erheblicher nicht-Clifford-Evolution.

Der Stabilisierungssimulator unterstützt Q#, OpenQASM, Qiskit und QIR Programme. In dieser Tabelle wird gezeigt, wie 10 Durchläufe in jedem Framework ausgeführt werden.

Die APIs NeutralAtomDevice und NeutralAtomBackend sind speziell für Simulationen auf Quantencomputern mit neutralen Atomen gedacht. Weitere Informationen finden Sie unter Übersicht über den Neutralatom-Gerätesimulator.

Beispielsweise führt dieser Python Code ein OpenQASM Programm mit einem Nicht-Clifford $T$-Gate auf dem Stabilisator-Simulator aus:

from qdk.openqasm import run

qasm_code = """
include "stdgates.inc";
qubit[1] q;
bit[1] result;

h q[0];
t q[0];
h q[0];
result = measure q;
"""

run(qasm_code, type="stabilizer", shots=1000)

Das $T$-Gatter erzeugt Stabilisatorzweige. Die abschließende Messung misst die Interferenzen zwischen jenen Zweigen.

Rufen Sie die GPU- und CPU-Simulatoren auf

Die GPU Und CPU Simulatoren unterstützen Qiskit und QIR programme. In dieser Tabelle wird gezeigt, wie 10 Shots im GPU Simulator mit dem qdk Paket in den einzelnen Frameworks ausgeführt werden. Um den CPU Simulator zu verwenden, ersetzen Sie gpu durch cpu im Simulatortypparameter.

Mit diesem Python Code wird beispielsweise ein einfaches OpenQASM Programm in QIR konvertiert und das GPU auf dem QIR-Simulator ausgeführt:

from qdk.openqasm import compile
from qdk.simulation import run_qir

qasm_code = """
    include "stdgates.inc";
    qubit[2] q;
    reset q;
    h q[0];
    cx q[0], q[1];
    bit c = measure q[1];
    """

qir = compile(qasm_code)
run_qir(qir, type="gpu", shots=10)