Kwantumsimulaties uitvoeren met het QDKPython pakket

Het MicrosoftQuantum Development-kit (QDK) Python pakket bevat lokale kwantumsimulators die u kunt gebruiken om kwantumprogramma's te testen en te ontwikkelen. In dit artikel wordt uitgelegd hoe u de simulators installeert en de programma's Q#, OpenQASM, Qiskit en QIR uitvoert in Python of Jupyter Notebook.

Het QDKPython pakket bevat vier primaire simulators:

• Sparse-simulator
• Stabilisatorsimulator
• GPU simulator
• CPU simulator

Zie QDKvoor meer informatie over de QDK kwantumsimulators.

Zie Kwantumsimulaties uitvoeren in de QDK-extensie voor Visual Studio Code om QDK- of Q#-programma's rechtstreeks in de OpenQASM-extensie voor Visual Studio Code (VS Code) uit te voeren.

Prerequisites

Als u de Jupyter Notebook voorbeelden in dit artikel wilt volgen, installeert u deze hulpprogramma's:

• Een Python omgeving met Python 3.10 of hoger en pip
• De nieuwste versie van Visual Studio Code (VS Code)
• De nieuwste versies van de Python extensie en Jupyter-extensie in VS Code

De simulators installeren

Als u de kwantumsimulators in Python en Jupyter Notebook wilt gebruiken, installeert u de nieuwste versie van het qdkPython pakket met de jupyter extra:

pip install --upgrade "qdk[jupyter]"

De simulators vereisen niet de jupyter extra, maar de extra voegt de qdk.widgets module toe om simulatieresultaten in Jupyter Notebook te visualiseren.

Selecteer een simulator op basis van het kwantumprogrammeerframework en de API die u gebruikt.

De sparse-simulator aanroepen

De sparse-simulator ondersteunt Q#, OpenQASMen Qiskit programma's. In deze tabel ziet u hoe u 10 shots uitvoert met het qdk pakket in elk framework.

Voer bijvoorbeeld de volgende stappen uit om het Bell-paarprogramma Q# uit te voeren in een Jupyter-notebook in VS Code:

1. Selecteer in VS Code Weergeven>.

2. Voer Create: New Jupyter Notebook in. Er wordt een leeg notitieblokbestand geopend op een nieuw tabblad.

3. Importeer in de eerste cel de qsharp module uit het qdk pakket.

   from qdk import qsharp
   

4. Gebruik in een nieuwe cel de magic-opdracht %%qsharp om de Q# code te schrijven.

   %%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. Maak een nieuwe cel. Als u het Q# programma wilt uitvoeren op de sparse simulator, roept u de run functie aan vanuit de qsharp module en geeft u het aantal shots op.

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

De stabilisatorsimulator aanroepen

De stabilisatorsimulator voert efficiënt brede, Clifford-gedomineerde schakelingen uit. Stabilisatorvertakking ondersteunt ook een beperkt aantal niet-Clifford-bewerkingen, zoals $T$- en $T^\dagger$-poorten en willekeurige-hoekrotaties Pauli . Omdat het aantal vertakkingen exponentieel kan groeien met het aantal niet-Clifford-bewerkingen, gebruikt u een full-state simulator voor circuits met een aanzienlijke niet-Clifford-evolutie.

De stabilisatorsimulator ondersteunt Q#, OpenQASM, QIR en Qiskit programma's. In deze tabel ziet u hoe u 10 runs uitvoert in elk framework.

De NeutralAtomDevice en NeutralAtomBackend API's zijn specifiek bedoeld voor simulaties op neutrale kwantumcomputers van atoom. Zie Overzicht van de simulator voor neutrale atoomapparaten voor meer informatie.

Met deze Python code wordt bijvoorbeeld een OpenQASM programma uitgevoerd met een niet-Clifford $T$-poort op de stabilisatorsimulator:

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)

De $T$ gate creëert stabilizer branches. De uiteindelijke meting meet de interferentie tussen die takken.

De GPU- en CPU-simulatoren aanroepen

De GPU en CPU simulatoren ondersteunen Qiskit en QIR programma's. In deze tabel ziet u hoe u 10 shots uitvoert op de GPU simulator met het qdk pakket in elk framework. Als u de CPU simulator wilt gebruiken, vervang gpu door cpu in de parameter van het simulatortype.

Met deze Python code wordt bijvoorbeeld een eenvoudig OpenQASM programma geconverteerd naar QIR en wordt de QIR op de GPU simulator uitgevoerd:

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)

Verwante onderwerpen

• Stel de MicrosoftQuantum Development-kit in
• Hoe QDK te installeren voor foutcorrectie