Introduzione al linguaggio di programmazione quantistica Q#

Q#è un linguaggio di programmazione open source di alto livello per lo sviluppo e l'esecuzione di algoritmi quantistici. Q# è incluso in Quantum Development Kit (QDK). Per altre informazioni, vedere Configurare Quantum Development Kit.

Come linguaggio di programmazione quantistica, Q# soddisfa i requisiti di linguaggio, compilatore e runtime seguenti:

• Indipendente dall'hardware: i qubit negli algoritmi quantistici non sono associati a un hardware quantistico o a un layout specifico. Il Q# compilatore e il runtime gestiscono il mapping dai qubit del programma ai qubit fisici.
• Integra il calcolo quantistico e classico: la possibilità di eseguire calcoli classici e quantistici è essenziale in un computer quantistico universale.
• Rispetta le leggi della fisica:Q# e gli algoritmi quantistici seguono le regole della fisica quantistica. Ad esempio, non è possibile copiare o accedere direttamente allo stato del qubit in Q#.

Struttura di un Q# programma

Prima di iniziare a scrivere programmi quantistici, è importante comprendere la struttura e i componenti. Si consideri il programma seguente Q# che crea uno stato di sovrapposizione:

namespace Superposition {
    @EntryPoint()
    operation MeasureOneQubit() : Result {
        // Allocate a qubit. By default, it's in the 0 state.  
        use q = Qubit();  
        // Apply the Hadamard operation, H, to the state.
        // It now has a 50% chance of being measured as 0 or 1.
        H(q);      
        // Measure the qubit in the Z-basis.
        let result = M(q);
        // Reset the qubit before releasing it.
        Reset(q);
        // Return the result of the measurement.
        return result;
    }
}

In base ai commenti (//), il Superposition programma alloca prima un qubit, applica un'operazione per inserire il qubit in sovrapposizione, misura lo stato del qubit, reimposta il qubit e infine restituisce il risultato. Di seguito viene illustrato come suddividere il programma nei relativi componenti.

Spazi dei nomi utente

Q#i programmi possono iniziare facoltativamente con uno spazio dei nomi definito dall'utente, ad esempio:

namespace Superposition {
    // Your code goes here.
}

Gli spazi dei nomi consentono di organizzare le funzionalità correlate. Ogni Q# programma può avere un namespacesolo . Se non viene specificato uno spazio dei nomi, il Q# compilatore usa il nome file come spazio dei nomi. Ad esempio, il Superposition programma può essere scritto come:

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

La Q# libreria standard include spazi dei nomi predefiniti che contengono funzioni e operazioni che è possibile usare nei programmi quantistici. Per altre informazioni, vedere Spazi dei nomi predefiniti.

Punti di ingresso

Per impostazione predefinita, il compilatore avvia l'esecuzione Q# di un programma dall'operazione Main() , se disponibile, che può trovarsi in qualsiasi punto del programma. Facoltativamente, è possibile usare l'attributo @EntryPoint() per specificare qualsiasi operazione nel programma come punto di esecuzione.

Superposition Nel programma, l'operazione più descrittiva MeasureOneQubit() è il punto di ingresso del programma.

@EntryPoint()
operation MeasureOneQubit() : Result {
    ...

Tuttavia, il programma può anche essere scritto senza l'attributo @EntryPoint() rinominando l'operazione MeasureOneQubit() in Main():

// The Q# compiler automatically detects the Main() operation as the entry point. 

operation Main() : Result {
    // Allocate a qubit. By default, it's in the 0 state.  
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1.
    H(q);      
    // Measure the qubit in the Z-basis.
    let result = M(q);
    // Reset the qubit before releasing it.
    Reset(q);
    // Return the result of the measurement.
    return result;
}

Tipi

Q#fornisce tipi predefiniti comuni alla maggior parte dei linguaggi, inclusi Inti tipi , Double, Boole Stringe specifici per il calcolo quantistico. Ad esempio, il Result tipo rappresenta il risultato di una misurazione di qubit e può avere uno dei due valori: Zero o One.

Superposition Nel programma l'operazione MeasureOneQubit() restituisce un Result tipo, che corrisponde al tipo restituito dell'operazioneM. Il risultato della misurazione viene archiviato in una nuova variabile definita usando l'istruzione let :

// The operation definition returns a Result type.
operation MeasureOneQubit() : Result {
    ...
    // Measure the qubit in the Z-basis, returning a Result type.
    let result = M(q);
    ...

Q# include anche tipi che definiscono intervalli, matrici e tuple. Si possono persino definire tipi personalizzati.

Allocazione di qubit

In Q#allocare qubit usando la use parola chiave . I qubit vengono sempre allocati nello $\ket{0}$ stato .

Il Superposition programma definisce un singolo qubit:

// Allocate a qubit.
use q = Qubit();

È anche possibile allocare più qubit e accedervi tramite il relativo indice:

use qubits = Qubit[2]; // Allocate two qubits.
H(qubits[0]); // Apply H to the first qubit.
X(qubits[1]); // Apply X to the second qubit.

Per altre informazioni, vedere Istruzione Use.

Operazioni quantistiche

Dopo aver allocato un qubit, è possibile passarlo alle operazioni e alle funzioni, note anche come chiamabili. Le operazioni sono i blocchi predefiniti di base di un programma Q#. Un'operazione Q# è una subroutine quantistica o una routine chiamabile che contiene operazioni quantistico che modificano lo stato del registro qubit.

Per definire un'operazione Q# , specificare un nome per l'operazione, i relativi input e il relativo output. Superposition Nel programma, l'operazione MeasureOneQubit() è essenzialmente l'intero programma. Non accetta parametri e restituisce un Result tipo:

operation MeasureOneQubit() : Result {
    ...
}

Di seguito è riportato un esempio di base che non accetta parametri e non prevede alcun valore restituito. Il Unit valore è equivalente a NULL in altre lingue:

operation SayHelloQ() : Unit {
    Message("Hello quantum world!");
}

La Q# libreria standard fornisce anche operazioni che è possibile usare nei programmi quantistici, ad esempio l'operazione Hadamard, H, nel Superposition programma. Dato un qubit sulla base Z, H inserisce il qubit in una sovrapposizione uniforme, dove ha una probabilità del 50% di essere misurata come Zero o One.

Misurazione dei qubit

Anche se esistono molti tipi di misurazioni quantistiche, Q# si concentra sulle misurazioni proiettate su singoli qubit, note anche come misurazioni Pauli.

In Q#l'operazione Measure misura uno o più qubit nella base Pauli specificata, che può essere PauliX, PauliYo PauliZ. Measure restituisce un Result tipo di Zero o One.

Per implementare una misura nella base $computazionale \lbrace\ket{0},\ket{1}\rbrace$, è anche possibile usare l'operazione M , che misura un qubit in base a Pauli Z. Ciò equivale M a Measure([PauliZ], [qubit]).

Il Superposition programma usa l'operazione M :

// Measure the qubit in the Z-basis.
let result = M(q);

Reimpostazione dei qubit

In Q#i qubit devono trovarsi nello $\ket{0}$ stato quando vengono rilasciati. Usare l'operazione Reset per reimpostare ogni qubit $\ket{0}$ sullo stato prima di rilasciarlo alla fine del programma. Il mancato ripristino di un qubit genera un errore di runtime.

// Reset a qubit.
Reset(q);

Spazi dei nomi predefiniti

La Q# libreria standard include spazi dei nomi predefiniti che contengono funzioni e operazioni che è possibile usare nei programmi quantistici. Ad esempio, lo Microsoft.Quantum.Intrinsic spazio dei nomi contiene funzioni e operazioni di uso comune, ad esempio M per misurare i risultati e Message per visualizzare i messaggi utente in qualsiasi punto del programma.

Per chiamare una funzione o un'operazione, è possibile specificare lo spazio dei nomi completo o usare un'istruzione import , che rende disponibili tutte le funzioni e le operazioni per tale spazio dei nomi e rende il codice più leggibile. Gli esempi seguenti chiamano la stessa operazione:

Microsoft.Quantum.Intrinsic.Message("Hello quantum world!");

// imports all functions and operations from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.*;
Message("Hello quantum world!");

// imports just the `Message` function from the Microsoft.Quantum.Intrinsic namespace.
import Microsoft.Quantum.Intrinsic.Message;
Message("Hello quantum world!");

// namespaces in the standard library may be imported using `Std` instead of `Microsoft.Quantum`. 
import Std.Intrinsic.*;
Message("Hello quantum world!");

Il Superposition programma non dispone import di istruzioni o chiamate con spazi dei nomi completi. Questo perché l'ambiente Q# di sviluppo carica automaticamente due spazi dei nomi: Microsoft.Quantum.Core e Microsoft.Quantum.Intrinsic, che contengono funzioni e operazioni comunemente usate.

È possibile sfruttare lo Microsoft.Quantum.Measurement spazio dei nomi usando l'operazione MResetZ per ottimizzare il Superposition programma. MResetZ combina le operazioni di misurazione e reimpostazione in un unico passaggio, come nell'esempio seguente:

// Import the namespace for the MResetZ operation.
import Microsoft.Quantum.Measurement.*;

@EntryPoint()
operation MeasureOneQubit() : Result {
    // Allocate a qubit. By default, it's in the 0 state.      
    use q = Qubit();  
    // Apply the Hadamard operation, H, to the state.
    // It now has a 50% chance of being measured as 0 or 1. 
    H(q);   
    // Measure and reset the qubit, and then return the result value.
    return MResetZ(q);
}

Sviluppare programmi quantistici con Q# e Azure Quantum

Q# e Azure Quantum sono una combinazione potente per lo sviluppo e l'esecuzione di programmi quantistici. Con Q# e Azure Quantum è possibile scrivere programmi quantistici, simularne il comportamento, stimare i requisiti delle risorse ed eseguirli su hardware quantistico reale. Questa integrazione consente di esplorare il potenziale del calcolo quantistico e sviluppare soluzioni innovative per problemi complessi. Che si sia principianti o esperti sviluppatori quantistici e Q# Azure Quantum fornisca gli strumenti e le risorse necessari per sbloccare la potenza del calcolo quantistico.

Il diagramma seguente illustra le fasi attraverso le quali passa un programma quantistico durante lo sviluppo con Q# e Azure Quantum. Il programma inizia con l'ambiente di sviluppo e termina con l'invio del processo all'hardware quantistico reale.

Di seguito vengono descritti i passaggi del diagramma.

Scegliere l'ambiente di sviluppo in uso

Eseguire i programmi quantistici nell'ambiente di sviluppo preferito. È possibile usare l'editor di codice online nel sito Web di Azure Quantum, i notebook jupyter ospitati nell'area di lavoro di Azure Quantum nel portale di Azure o un ambiente di sviluppo locale con Visual Studio Code. Per altre informazioni, vedere Diversi modi per eseguire Q# i programmi.

Scrivere il programma quantistico

È possibile scrivere programmi quantistici in Q# usando Quantum Development Kit (QDK). Per iniziare, vedere Avvio rapido: Creare il primo Q# programma.

Oltre Q#a , QDK offre supporto per altri linguaggi per il calcolo quantistico, ad esempio Qiskit e Cirq.

Integrazione con Python

È possibile usare Q# da solo o insieme a Python in vari IDE. Ad esempio, è possibile usare un Q# progetto con un programma host Python per chiamare Q# le operazioni. È anche possibile eseguire l'integrazione Q# con Python in Jupyter Notebooks. Per altre informazioni, vedere Diversi modi per eseguire Q# i programmi.

Comando %%qsharp

Per impostazione predefinita, Q# i programmi in Jupyter Notebook usano il ipykernel pacchetto Python. Per aggiungere Q# codice a una cella del notebook, usare il %%qsharp comando , che è abilitato con il qsharp pacchetto Python, seguito dal Q# codice.

Quando si usa %%qsharp, tenere presente quanto segue:

• È necessario prima eseguire import qsharp per abilitare %%qsharp.
• %%qsharp ha come ambito la cella del notebook in cui viene visualizzata e modifica il tipo di cella da Python a Q#.
• Non è possibile inserire un'istruzione Python prima o dopo %%qsharp.
• Q# il codice seguente %%qsharp deve essere conforme alla Q# sintassi. Ad esempio, usare // anziché # per indicare i commenti e ; per terminare le righe di codice.

Stimare le risorse

Prima di eseguire su hardware quantistico reale, è necessario determinare se il programma può essere eseguito su hardware esistente e quante risorse utilizzeranno.

Azure Quantum Resource Estimator consente di valutare le decisioni dell'architettura, confrontare le tecnologie qubit e determinare le risorse necessarie per eseguire un determinato algoritmo quantistico. È possibile scegliere tra protocolli a tolleranza di errore predefiniti e specificare presupposti del modello qubit fisico sottostante.

Per altre informazioni, vedere Eseguire la prima stima delle risorse.

Eseguire il programma nella simulazione

Quando si compila ed esegue un programma quantistico, QDK crea un'istanza del simulatore quantistico e vi passa il Q# codice. Il simulatore usa il codice Q# per creare i qubit (simulazioni di particelle quantistiche) e applicare le trasformazioni per modificarne lo stato. I risultati delle operazioni quantistiche nel simulatore vengono quindi restituiti al programma. L'isolamento del codice Q# nel simulatore garantisce che gli algoritmi seguano le leggi della fisica quantistica e possano essere eseguiti correttamente nei computer quantistici.

Inviare il programma all'hardware quantistico reale

È possibile inviare i Q# programmi (noti anche come processi) ad Azure Quantum tramite l'ambiente di sviluppo preferito, sia in locale che online. Per altre informazioni, vedere come inviare Q# processi. È anche possibile eseguire e inviare circuiti quantistici scritti in linguaggi Qiskit e Cirq.

Azure Quantum offre alcuni degli hardware quantistici più interessanti e diversificati attualmente disponibili dai leader del settore. Vedere Provider di calcolo quantistico per l'elenco corrente dei provider hardware supportati.

Il diagramma seguente mostra il flusso di lavoro di base dopo l'invio del processo:

Contenuto correlato

• Modi diversi per eseguire Q# programmi
• Configurare Quantum Development Kit
• Guida introduttiva: Creare il primo Q# programma