Manuale dell'utente del Q# linguaggio di programmazione quantistica
Il Q# linguaggio di programmazione quantistico fa parte di Microsoft, che fornisce supporto e strumenti avanzati per la visualizzazione e l'analisi del Quantum Development Kitprogramma. Con Q# e Quantum Development Kit (QDK) è possibile scrivere i programmi quantistici ed eseguirli su hardware quantistico reale usando Azure Quantum.
Per altre informazioni, vedere come configurare l'ambiente di sviluppo quantistico e come inviare Q# processi ad Azure Quantum.
Il manuale dell'utente di Q# contiene:
Modalità di esecuzione di un programma Q#: un programma Q# può essere eseguito come applicazione autonoma o con un programma host aggiuntivo, scritto in Python o in un linguaggio .NET.
Test e debug dei programmi Q#: come per la programmazione classica, è essenziale essere in grado di verificare che i programmi quantistici agiscano come previsto e di diagnosticare un comportamento non corretto. Oggetto Quantum Development Kit per il test e il debug di programmi quantistici.
Guida al linguaggio Q#: Q# è un linguaggio autonomo che offre un elevato livello di astrazione. Non occorre alcuna nozione di stato quantistico o circuito. Q# implementa invece i programmi in termini di istruzioni ed espressioni, in modo molto simile ai linguaggi di programmazione classici. La guida al linguaggio Q# include le specifiche complete e la documentazione del linguaggio di programmazione quantistico Q#.
Documentazione sui simulatori quantistici: i simulatori quantistici sono programmi software eseguiti in computer classici e fungono da target computer per un Q# programma, rendendo possibile l'esecuzione e il test dei programmi quantistici nei computer classici.
La Q# documentazione della libreria: Quantum Development Kit fornisce funzionalità aggiuntive specifiche del dominio tramite pacchetti NuGet che possono essere aggiunti ai Q# progetti. La documentazione include operazioni, funzioni, tipi definiti dall'utente, esempi e concetti che costituiscono la libreria standard Q#, nonché le librerie di chimica quantistica, Machine Learning quantistico e per calcoli numerici quantistici.
Quali elementi compongono un programma Q#?
Di seguito verranno presentati i componenti generali inclusi in un programma Q#. Si consideri il programma Q# seguente:
namespace HelloQuantum {
open Microsoft.Quantum.Canon;
open Microsoft.Quantum.Intrinsic;
@EntryPoint()
operation SayHelloQ() : Unit {
Message("Hello quantum world!");
}
}
EntryPoint indica al compilatore Q# di iniziare a eseguire il programma. Il programma stampa il messaggio seguente:
Hello quantum world!
Spazi dei nomi
Ogni file Q# inizia in genere con uno spazio dei nomi. Ecco un esempio:
namespace HelloQuantum {
// Your code goes here.
}
Gli spazi dei nomi consentono di organizzare le funzionalità correlate. Il loro uso diventa importante quando si usano librerie Q# nei programmi e quando si scrivono librerie personalizzate.
Librerie
Q# fa ampio uso di librerie. Una libreria è un pacchetto che contiene funzioni e operazioni che è possibile usare nei programmi quantistici.
Ad esempio, la libreria Microsoft.Quantum.Chemistry consente di eseguire calcoli quantistici correlati alla chimica. Ci sono diverse librerie standard, che includono tutti i tipi di operazioni di base.
Quando si chiama una funzione o un'operazione da una libreria, si specifica lo spazio dei nomi della libreria. Di seguito è riportato un esempio che chiama la funzione Message dalla libreria Microsoft.Quantum.Intrinsic per stampare un messaggio nella console:
namespace HelloQuantum {
@EntryPoint()
operation SayHelloQ() : Unit {
Microsoft.Quantum.Intrinsic.Message("Hello quantum world!");
}
}
Più comunemente, si usa la direttiva open per rendere il codice più conciso e più semplice da leggere.
Questo esempio fa la stessa cosa dell'esempio precedente, ma usa la direttiva open per inserire lo spazio dei nomi Microsoft.Quantum.Intrinsic nel programma:
namespace HelloQuantum {
open Microsoft.Quantum.Intrinsic;
@EntryPoint()
operation SayHelloQ() : Unit {
Message("Hello quantum world!");
}
}
Qui si specifica semplicemente Message e il compilatore riconosce lo spazio dei nomi a cui appartiene.
La documentazione di Q# fornisce informazioni di riferimento complete per ogni libreria predefinita. Per altre informazioni, vedere la documentazione delle librerie Q#.
Tipi
Q# fornisce diversi tipi predefiniti con cui si ha già familiarità, tra cui Int, Double, Bool e String, oltre a tipi specifici del calcolo quantistico. Il tipo Result, ad esempio, rappresenta il risultato della misurazione di un qubit e può avere uno dei due valori possibili: One e Zero. Q# include anche tipi che definiscono intervalli, matrici e tuple. Si possono persino definire tipi personalizzati.
In generale, il sistema dei tipi di Q# è piuttosto minimale, nel senso che non esiste una nozione esplicita di classi o interfacce come quella a cui si potrebbe essere abituati come utenti di linguaggi classici come C# o Java.
Allocazione di qubit
In Q# i qubit vengono allocati tramite la parola chiave use. È possibile allocare uno o più qubit alla volta.
Nell'esempio seguente viene allocato un qubit:
// Allocate a qubit.
use q = Qubit();
// Do something with q here.
Per impostazione predefinita, ogni qubit allocato con la parola chiave use inizia con lo stato zero.
Operazioni quantistice
Una volta allocato, un qubit può essere passato a operazioni e funzioni, definite anche elementi chiamabili. In un certo senso, questo è tutto ciò che un programma Q# può fare con un qubit. Le operazioni sono i blocchi predefiniti di base di un programma Q#. Un'operazione Q# è una subroutine quantistica. Ovvero, una routine chiamabile che contiene operazioni quantistiche che modificano lo stato del registro qubit.
Per definire un'operazione Q#, è necessario specificare un nome per l'operazione insieme ai relativi input e output. Ecco un esempio di base:
operation SayHelloQ() : Unit {
Message("Hello quantum world!");
}
In questo caso, il nome dell'operazione è SayHelloQ. Accetta zero argomenti come input e restituisce il tipo Unit, che significa che l'operazione non restituisce alcuna informazione.
Le Q# librerie forniscono anche operazioni che è possibile usare nei programmi, ad esempio l'operazione o H Hadamard. Dato un qubit in Z, l'operazione H inserisce il qubit in una sovrapposizione uniforme . Una volta in sovrapposizione, il qubit ha una probabilità del 50% di essere misurata come zero o uno.
Tutte le azioni dirette sullo stato di un qubit sono tutte definite da chiamabili intrinseci , ad esempio X e H , ovvero callable le cui implementazioni non sono definite all'interno Q# , ma sono definite dal target computer. Le operazioni eseguite in realtà sono rese concrete solo dal target computer scelto per eseguire il programma specifico Q# . Per altre informazioni, vedere Implementazione dei programmi Q#.
Ad esempio, se si esegue il programma nel simulatore di stato completo, il simulatore esegue le operazioni matematiche corrispondenti al sistema quantistico simulato. Tuttavia, guardando verso il futuro, quando la target macchina è un computer quantistico reale, la chiamata di tali operazioni in Q# indirizza il computer quantistico per eseguire le operazioni reali corrispondenti sull'hardware quantistico reale. Ad esempio, in un computer quantistico a ioni intrappolati, le operazioni quantistiche vengono eseguite da impulsi laser temporizzati con precisione.
Un Q# programma ricombina queste operazioni come definito da un target computer per creare nuove operazioni di livello superiore per esprimere il calcolo quantistico. In questo modo, Q# consente di esprimere facilmente la logica sottostante algoritmi quantistici e ibridi quantistici classici, pur essendo generale rispetto alla struttura di un computer o di un target simulatore.
Misurazione dei qubit
Esistono molti tipi di misurazioni quantistiche, ma Q# si concentra sulle misurazioni proiettative su singoli qubit, note anche come misurazioni Pauli. In base a una determinata misura (ad esempio, la base di calcolo $\ket{0},\ket{1}$) lo stato del qubit viene proiettato su qualsiasi stato di base misurato, di conseguenza distruggendo qualsiasi sovrapposizione tra i due.
In Q#le misurazioni Pauli vengono eseguite applicando Measure l'operazione, che esegue una misurazione congiunta di uno o più qubit nelle basi Pauli specificate. Measure l'operazione restituisce un Result tipo.
Nota
Se la matrice di base e la matrice di qubit sono lunghezze diverse, l'operazione Measure avrà esito negativo.
Per implementare una misura nella base di calcolo $\ket{0},\ket{1}$, è anche possibile usare l'operazioneM, il quale esegue una misurazione di un singolo qubit nella base Pauli Z. Pertanto M , l'operazione equivale all'applicazione di Measure([PauliZ], [qubit]).
Un semplice esempio è il programma seguente, che alloca un qubit nello stato $\ket{0}$, quindi vi applica un'operazione Hadamard H e misura il risultato nella base PauliZ.
@EntryPoint()
operation MeasureOneQubit() : Result {
// Allocate a qubit, by default it is in zero state
use q = Qubit();
// We apply a Hadamard operation H to the state
// It now has a 50% chance of being measured 0 or 1
H(q);
// Now we measure the qubit in Z-basis.
let result = M(qubit);
// We reset the qubit before releasing it.
if result == One { X(qubit); }
// Finally, we return the result of the measurement.
return result;
}
Per eseguire misurazioni oltre una singola misura congiunta, lo Microsoft.Quantum.Measurement spazio dei nomi include operazioni più specifiche. Ad esempio, l'operazioneMultiM accetta una matrice di qubit e restituisce una matrice di risultati di misurazione nella base di calcolo.