Esegui simulazioni quantistiche con il QDKPython pacchetto

Il MicrosoftQuantum Development Kit pacchetto (QDK) Python include simulatori quantistici locali che è possibile usare per testare e sviluppare programmi quantistici. Questo articolo illustra come installare i simulatori ed eseguire i programmi Q#, OpenQASM, Qiskit e QIR in Python o Jupyter Notebook.

Il QDKPython pacchetto include quattro simulatori primari:

• Simulatore di tipo sparse
• Simulatore di stabilizzatore
• GPU simulatore
• CPU simulatore

Per altre informazioni sui QDK simulatori quantistici, vedere Panoramica dei simulatori quantistici in QDK.

Per eseguire Q# o OpenQASM programmi direttamente nell'estensione QDK per Visual Studio Code (VS Code), vedere Eseguire simulazioni quantistiche nell'estensione QDK per Visual Studio Code.

Prerequisiti

Per seguire gli esempi di Jupyter Notebook in questo articolo, installare questi strumenti:

• Ambiente Python con Python 3.10 o versione successiva e pip
• Versione più recente di Visual Studio Code (VS Code)
• Le versioni più recenti dell'Pythonestensione e dell'estensione Jupyter in VS Code

Installare i simulatori

Per usare i simulatori quantistici in Python e Jupyter Notebook, installare la versione più recente del qdkPython pacchetto con gli jupyter elementi aggiuntivi:

pip install --upgrade "qdk[jupyter]"

I simulatori non richiedono l'jupyter extra, ma l'extra aggiunge il modulo qdk.widgets per visualizzare i risultati della simulazione in Jupyter Notebook.

Selezionare un simulatore basato sul framework di programmazione quantistica e all'API Python usata.

Chiamare il simulatore di tipo sparse

Il simulatore sparse supporta Q#, OpenQASM e Qiskit programmi. Questa tabella illustra come eseguire 10 esecuzioni con il qdk pacchetto in ogni framework.

Ad esempio, seguire questa procedura per eseguire il programma di coppia Q# Bell in un notebook jupyter in VS Code:

1. In VS Code selezionare Visualizza>Palette dei comandi.

2. Inserisci Crea: Nuovo Jupyter Notebook. Verrà aperto un file di notebook vuoto in una nuova scheda.

3. Nella prima cella importare il qsharp modulo dal qdk pacchetto.

   from qdk import qsharp
   

4. In una nuova cella usare il %%qsharp comando magic per scrivere il Q# codice.

   %%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. Creare una nuova cella. Per eseguire il Q# programma nel simulatore di tipo sparse, chiamare la run funzione dal qsharp modulo e specificare il numero di scatti.

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

Chiamare il simulatore di stabilizzatore

Il simulatore di stabilizzatore esegue in modo efficiente circuiti ampi dominati da Clifford. La ramificazione del formalismo degli stabilizzatori supporta anche un numero limitato di operazioni non-Clifford, come le porte $T$ e $T^\dagger$ e rotazioni di Pauli con angolo arbitrario. Poiché il numero di rami può crescere in modo esponenziale con il numero di operazioni non-Clifford, utilizza un simulatore di stato completo per circuiti con un'evoluzione sostanziale non-Clifford.

Il simulatore di stabilizzatore supporta i programmi Q#, OpenQASM, Qiskit e QIR. Questa tabella illustra come eseguire 10 esecuzioni in ogni framework.

Le API NeutralAtomDevice e NeutralAtomBackend sono pensate specificamente per le simulazioni su computer quantistici a atomi neutri. Per altre informazioni, vedi Panoramica del simulatore di dispositivi a atomi neutri.

Ad esempio, questo Python codice esegue un OpenQASM programma con un gate non-Clifford $T$ nel simulatore stabilizer:

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)

Il gate $T$ crea rami stabilizzatori. La misurazione finale misura l'interferenza tra tali rami.

Chiamare i simulatori GPU e CPU

I simulatori GPU e CPU supportano programmi Qiskit e QIR. Questa tabella illustra come eseguire 10 esecuzioni nel simulatore GPU con il pacchetto qdk in ogni framework. Per usare il CPU simulatore, sostituire gpu con cpu nel parametro del tipo di simulatore.

Ad esempio, questo Python codice converte un semplice OpenQASM programma in QIR ed esegue il QIR nel simulatore 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)