Uruchamiaj symulacje kwantowe przy użyciu pakietu QDKPython

Pakiet MicrosoftQuantum Development Kit (QDK) Python zawiera lokalne symulatory kwantowe, których można używać do testowania i opracowywania programów kwantowych. W tym artykule wyjaśniono, jak zainstalować symulatory i uruchomić programy Q#, OpenQASM, Qiskit i QIR w programie Python lub Jupyter Notebook.

Pakiet QDKPython zawiera cztery podstawowe symulatory:

• Symulator rzadki
• Symulator stabilizatora
• GPU symulator
• CPU symulator

Aby uzyskać więcej informacji na temat QDKsymulatorów kwantowych, zobacz Omówienie symulatorów kwantowych w programie QDK.

Aby uruchomić programy Q# lub OpenQASM bezpośrednio w rozszerzeniu QDK dla Visual Studio Code (VS Code), zobacz Uruchamianie symulacji kwantowych w rozszerzeniu QDK dla Visual Studio Code.

Prerequisites

Aby postępować zgodnie z przykładami Jupyter Notebook w tym artykule, zainstaluj następujące narzędzia:

• Python Środowisko z Python wersją 3.10 lub nowszą i pip
• Najnowsza wersja Visual Studio Code (VS Code)
• Najnowsze wersje rozszerzenia Python i rozszerzenia Jupyter w programie VS Code

Instalowanie symulatorów

Aby używać symulatorów kwantowych w systemach Python i Jupyter Notebook, zainstaluj najnowszą wersję pakietu qdkPython z dodatkiem jupyter:

pip install --upgrade "qdk[jupyter]"

Symulatory nie wymagają dodatku jupyter, ale ten dodatek dodaje moduł qdk.widgets w celu wizualizacji wyników symulacji w Jupyter Notebook.

Wybierz symulator na podstawie używanej platformy programowania kwantowego i Python interfejsu API.

Wywołaj rzadki symulator

Symulator rzadki obsługuje programy Q#, OpenQASM, i Qiskit. W tej tabeli przedstawiono sposób uruchamiania 10 uruchomień z pakietem qdk w każdym frameworku.

Wykonaj na przykład następujące kroki, aby uruchomić program par Bell Q# w notesie Jupyter w programie VS Code:

1. W programie VS Code wybierz pozycję Widok>paletę poleceń.

2. Wprowadź Create: New Jupyter Notebook. Pusty plik notesu zostanie otwarty na nowej karcie.

3. W pierwszej komórce zaimportuj moduł qsharp z pakietu qdk.

   from qdk import qsharp
   

4. W nowej komórce użyj %%qsharp polecenia magic, aby napisać Q# kod.

   %%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. Tworzenie nowej komórki. Aby uruchomić program Q# na symulatorze rozrzedzonym, wywołaj funkcję run z modułu qsharp i określ liczbę strzałów.

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

Wywołaj symulator stabilizatora

Symulator stabilizatora wydajnie uruchamia szerokie układy, zdominowane przez Clifford. Rozgałęzianie stabilizatora obsługuje również ograniczoną liczbę nie-Clifford operacji, takich jak $T$ i bramy $T^\dagger$ oraz obroty o dowolnym kącie Pauli. Ponieważ liczba gałęzi może rosnąć wykładniczo wraz z liczbą operacji nie-Clifford, należy użyć symulatora pełnego stanu dla obwodów ze znaczną ewolucją nie-Clifford.

Symulator stabilizatora obsługuje programy Q#, OpenQASM, Qiskit i QIR. W tej tabeli przedstawiono sposób uruchamiania 10 prób w każdym frameworku.

Interfejsy API NeutralAtomDevice i NeutralAtomBackend są przeznaczone specjalnie do symulacji na komputerach kwantowych wykorzystujących neutralne atomy. Aby uzyskać więcej informacji, zobacz Neutral atom device simulator overview (Omówienie neutralnego symulatora urządzenia atomowego).

Na przykład ten Python kod uruchamia OpenQASM program z nie-Cliffordbramą $T$ na symulatorze stabilizatora:

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)

Brama $T$ tworzy gałęzie stabilizatorowe. Końcowy pomiar próbkuje interferencję między tymi gałęziami.

Wywołaj symulatory GPU i CPU

Symulatory GPU i CPU obsługują programy QIR i Qiskit. W tej tabeli przedstawiono sposób uruchamiania 10 uruchomień na symulatorze GPU z pakietem qdk w każdym frameworku. Aby użyć symulatora CPU, w parametrze typu symulatora zastąp gpu przez cpu.

Na przykład ten Python kod konwertuje prosty OpenQASM program na QIR program i uruchamia QIR go w symulatorze GPU :

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)

Treści powiązane

• Skonfiguruj MicrosoftQuantum Development Kit
• Jak zainstalować QDK do korekcji błędów