Översikt över kvantsimulatorer i QDK

Microsoft Quantum Development Kit (QDK) innehåller kvantsimulatorer som kör kvantprogram på din lokala dator. Använd dessa lokala simulatorer för att testa och utveckla dina program innan du skickar dem till Azure Quantum målenheter.

QDK innehåller fyra primära simulatorer för att köra kvantprogram:

• Den glese simulatorn
• Stabilisatorsimulatorn
• Simulatorn GPU
• Simulatorn CPU

Den glese simulatorn

Simulatorn för glesa tillstånd representerar qubittillstånd som glesa vektorer och använder gles matrisalgebra för att snabbt simulera program som genererar få icke-noll-amplituder. Det är standardsimulatorn för programmen Q# och QDK i tillägget qsharp.run och för API:erna openqasm.run och PythonOpenQASM. Använd den glesa simulatorn när du vill ha snabba simuleringar av Q#, OpenQASMeller Qiskit program eller när du vill visa kvanttillståndet för ditt program under simuleringen.

Den sparse-simulatorn är tillgänglig i både QDK tillägget för Visual Studio Code (VS Code) och QDKPython paketet. Den här simulatorn är den enda simulatorn som är tillgänglig i QDK tillägget, så tillägget använder den automatiskt när du kör Q# och OpenQASM program i VS Code. I VS Code använder du Q#DumpMachine-funktionen eller felsökningsprogrammet för att visa qubittillståndsvektorer vid olika tidpunkter i simuleringen.

Både VS Code-tillägget och Python-paketet stöder brusmodeller för glesa simuleringar av Q#- och OpenQASM-program. Python Endast paketet stöder gles simulering av Qiskit-program, men det stöder inte brusmodeller för Qiskit-simuleringar.

Mer information om hur du kör simuleringar i tillägget finns i QDKKöra kvantsimuleringar i QDK tillägget för Visual Studio Code.

Stabilisatorsimulatorn

Stabilisatorsimulatorn simulerar snabbt och effektivt Clifford-dominerade program med tusentals kvantbitar. Clifford grindar är vanliga komponenter i kvantfelkorrigeringskretsar. Clifford operationer ökar inte antalet stabilisatorgrenar, så simulatorn kan tillämpa dem effektivt även i breda kretsar. Vanliga Clifford åtgärder är:

• $X$, $Y$, och $Z$
• $S$ och $S^\dagger$
• $H$, eller Hadamard
• $CX$, $CY$, och $CZ$
• $SWAP$

Stabilisatorsimulatorn använder också stabilisatorförgrening för att simulera kretsar med ett begränsat antal icke-Clifford operationer. Simulatorn stöder följande icke-Clifford operationer:

• $T$ och $T^\dagger$
• Rotationer med godtycklig vinkel för $R_X$, $R_Y$, $R_Z$, $R_{XX}$, $R_{YY}$ och $R_{ZZ}$

Varje operation som inte är Clifford kan öka antalet stabilisatorgrenar. Att lägga till icke-Cliffordoperationer kan öka minnesanvändningen och körtiden exponentiellt. Använd stabilisatorsimulatorn för breda kretsar med mestadels Clifford-operationer och ett blygsamt antal icke-Clifford-operationer. Använd en gles eller fulltillståndssimulator för kretsar som har många andra operationer än Clifford.

Stabilisatorsimulatorn stöder anpassningsbar körning, Pauli brus och kvantbitsförlust. Det är tillgängligt i QDKPython paketet för Q#, OpenQASM, Qiskitoch QIR program, men är inte tillgängligt i QDK tillägget för VS Code.

I Python API:er med en simulatorväljare använder du antingen "stabilizer" eller "clifford" för att välja stabilisatorsimulatorn.

Simulatorn GPU

Simulatorn GPU är en fulltillståndssimulator som använder datorns GPU för att köra många bilder av kvantprogrammet parallellt. Simulatorn stöder alla gatetyper men kräver betydande databehandlingsresurser. Simulatorn kan modellera upp till 27 kvantbitar. Kapaciteten hos datorns GPU avgör prestandan, men prestandan är optimal för program som har omkring 20 qubits och många körningar.

Simulatorn GPU accepterar QIR eller Qiskit som indata via vissa QDKPython paket-API:er. Tillägget VS Code stöder inte GPU-simulatorn. Det finns också omfattande stöd för brusmodeller på alla typer av kvantgrindar eller operationer.

Simulatorn CPU

Precis som simulatorn GPU är simulatorn CPU en fulltillståndssimulator som kör program med alla typer av kvantgrindar. Men det är långsammare eftersom det inte kan köra flera körningar parallellt. Den här simulatorn skalar upp till cirka 25 kvantbitar, men saktar ned exponentiellt med fler kvantbitar på grund av minnesproblem. Använd CPU-simulatorn när datorn inte har en GPU, eller när programmet har få kvantbitar och inte kräver många shots.

Simulatorn CPU accepterar QIR eller Qiskit indata. Du kan använda det via vissa QDKPython paket-API:er, men inte via VS Code tillägget. Det finns också omfattande stöd för brusmodeller på alla typer av kvantgrindar eller operationer.

Vilken simulator ska jag använda?

Tänk på dessa faktorer när du väljer en simulator:

• Din utvecklingsmiljö (VS Code eller Python)
• Det ramverk för kvantprogrammering som du använder
• Komplexiteten i ditt program och antalet bilder
• Maskinvarufunktionerna för din lokala dator
• Azure Quantum mål eller annan kvantmaskinvara som du vill köra dina program på
• De brusmodeller som du vill skapa

I följande tabell sammanfattas tillgängligheten för varje QDK simulator och kvantprogrammeringsramverk som stöds:

Simuleringar i QDK tillägget för VS Code

Tillägget QDK för VS Code stöder endast den glesa simulatorn. Om du vill använda sparse-simulatorn kör du din Q#- eller OpenQASM-fil i VS Code. Du kan lägga till Pauli brusmodeller till glesa simuleringar av Q# program i VS Code, men inte till OpenQASM program.

Simuleringar i QDKPython paketet

Paketet QDKPython stöder flera kvantprogrammeringsramverk och alla fyra QDK simulatorer. Kompatibiliteten varierar beroende på ramverk och API.

I följande tabell visas de simulatorer och programmeringsramverk som varje Python API stöder:

Relaterat innehåll

• Kör kvantsimuleringar med QDKPython-paketet
• Kör kvantsimuleringar i QDK tillägget för Visual Studio Code
• Så här skapar du brusmodeller för kvantsimuleringar i QDK
• Backend-kvantsimulatorer från kvantleverantörer