Novità di Azure Quantum Development Kit (QDK moderno)

  • Articolo

Il QDK moderno è la versione più recente degli strumenti di sviluppo e linguaggio Q#. Con un footprint più piccolo e prestazioni più veloci, è un'estensione di Visual Studio Code con un clic e offre miglioramenti del linguaggio, il supporto integrato di Python e Jupyter Notebook, il supporto della nuova sintassi, il supporto del debugger, il supporto di progetti multi-file, i messaggi di errore e la connettività integrata di Azure. Eliminando le dipendenze del QDK classico precedente, è ora veramente indipendente dalla piattaforma, in esecuzione in Windows, Mac, Linux e il Web.

Integrazione di Visual Studio Code

Il QDK moderno è strettamente integrato nell'ambiente di sviluppo di Visual Studio Code. Le nuove funzionalità includono:

  • Nuovo strumento di stima delle risorse per VS Code che è possibile eseguire in locale senza alcun account Azure necessario
  • Debugger Q# per il debug integrato con punti di interruzione, passaggi e visualizzazione variabili locali e quantistiche
  • Supporto per progetti Q# multi-file
  • Miglioramenti del server linguistico con la messaggistica degli errori, l'evidenziazione della sintassi, il completamento del codice, le informazioni sul puntatore del mouse e passare alle definizioni
  • Connettività e invio di processi dell'area di lavoro di Azure integrati
  • Simulatore sparse predefinito (senza rumore)
  • Jupyter Notebook integrazione con la codifica Q# nelle celle e nell'evidenziazione della sintassi
  • Generazione di QIR per i programmi Q#

Presto disponibile

  • L'elaborazione ibrida integrata con profilo adattivo non è ancora supportata con QDK moderno. Se è necessario eseguire progetti di calcolo ibridi, vedere Continuare a lavorare in QDK classico.

Funzionalità deprecate

Aggiornamenti del linguaggio Q#

Man mano che le scoperte quantistiche e le innovazioni continuano a evolversi a un ritmo rapido, il linguaggio Q# e azure Quantum Development Kit continuano a evolversi per soddisfare le esigenze di sviluppo quantistico attuali e future. Le sezioni seguenti descrivono le modifiche, gli aggiornamenti e i miglioramenti nella QDK moderna.

Aggiornamenti della sintassi del linguaggio

Basato su espressioni

Il linguaggio Q# è ora basato su espressioni anziché basato su istruzioni. In questo modo è possibile usare una nuova sintassi esistente, ad esempio incorporando un'espressione if in un'altra espressione:

let x = if check { 0 } else { 1 };

Restituzione implicita

L'esempio precedente sfrutta anche l'uso di istruzioni senza un punto e virgola finale alla fine di un blocco per restituire un valore da tale blocco. Questo modello può essere usato invece di espressioni restituite esplicite in una chiamata:

function ReturnsThree() : Int {
    return 3;
}

function AlsoReturnsThree() : Int {
    3
}

Espressioni di blocco

Q# supporta ora espressioni a blocchi che possono organizzare più righe, variabili di ambito e restituire un valore:

let flip = {
    use q = Qubit();
    H(q);
    if M(q) == One {
        X(q);
        "Heads"
    } else {
        "Tails"
    }
} ;

Elementi come istruzioni

Gli elementi come newtype, operationfunction e anche open possono essere visualizzati come istruzioni all'interno di un ambito locale. In questo modo è possibile definire tipi di helper locali e chiamate, nonché includere l'ambito. Ad esempio, una funzione helper locale può essere definita subito prima che sia necessaria:

function ShowDecrement() : Unit {
    open Microsoft.Quantum.Arrays;
    let before = [1, 2, 3];

    function SubOne(in : Int) : Int {
        in - 1
    }

    let after = Mapped(SubOne, before);
    // after will be [0, 1, 2]
}

Sia la funzione che l'apertura dello Microsoft.Quantum.Arrays spazio dei nomi sono con ambito alla ShowDecrement funzione SubOne e non influiscono sul codice esterno.

Ombreggiatura dei nomi

Q# ora consente l'ombreggiatura dei nomi risolti in cui questo è stato non consentito in precedenza. Ciò consente di riutilizzare più facilmente il codice che include nomi variabili o chiamabili senza la necessità di una variabile modificabile:

function Shadowing(input : Int) : Double {
    let input = 2 * input;
    let output = Calculate(input);
    let output = IntAsDouble(output);
    return output;
}

Tipi espliciti per le variabili locali

Le variabili locali possono ora essere digitate in modo esplicito usando la stessa sintassi dei tipi per dichiarazioni di argomenti chiamabili:

let x : Int[] = [];

I tipi espliciti non sono necessari, ma talvolta possono essere utili quando si risolve l'ambiguità dei tipi per le funzioni che accettano generics, ad esempio Length. Il modello precedente per la gestione di questa operazione, aggiungendo tipi concreti a una chiamata a una funzione generica con sintassi, Length<Int[]>([]); ad esempio , non è più supportata.

Prelude dello spazio dei nomi implicito

La risoluzione dei nomi incorpora ora un prelude implicito che è un set di spazi dei nomi trattati come se fosse stato aperto, purché nessun altro nome risolto li superi. Gli spazi dei nomi trattati in questo modo sono Microsoft.Quantum.Core, Microsoft.Quantum.Canone Microsoft.Quantum.Intrinsic. Queste non devono essere aperte in modo esplicito, tranne quando si usano alias o diversamente diversi da potenziali conflitti.

Libreria standard

La libreria standard Q# è ora ospitata nello stesso repository del compilatore e del runtime e può essere trovata nella cartella della libreria di primo livello. Non tutte le funzionalità e le funzionalità sono state migrate dalle librerie Q# classiche, a cui è ancora possibile accedere in https://github.com/microsoft/QuantumLibraries. Se è necessario un elemento della libreria precedente per un programma, tale elemento e tutte le dipendenze possono essere copiate nel programma di origine. Se qualsiasi funzionalità della libreria è fondamentale per un flusso di lavoro e deve essere considerata per l'inclusione nella nuova libreria standard, inviare un problema di GitHub con i dettagli.

Simulazione

Simulazione sparse per impostazione predefinita

Il QDK moderno usa un simulatore quantistico dello stato sparse predefinito come impostazione predefinita target per la simulazione locale. Questo simulatore viene scritto in Rust e proviene dal repository di Runner di QIR , consentendo la compilazione in WASM ed eseguito in un'ampia gamma di ambienti. Attualmente si tratta dell'unico back-end di simulazione disponibile in QDK, anche se altri back-end sono in considerazione per l'integrazione futura. Per altre informazioni sulla progettazione di simulazione sparse, vedere Test di algoritmi quantistici di grandi dimensioni tramite simulazione sparse.

Controlli più rigorosi sulla versione qubit

Il QDK classico aveva storicamente rilassato il requisito che i qubit si trovano nel terreno o |0⟩ stato prima di essere rilasciati alla fine del loro ambito, in modo che un qubit misurato e non eseguito su alcun altro fosse sicuro da rilasciare perché il simulatore reimpostava automaticamente il qubit. Tuttavia, ciò ha causato confusione quando lo stesso programma è stato eseguito su hardware quantistico reale in cui tale reimpostazione automatica non è presente e i qubit possono essere riutilizzati in uno stato imprevisto. Per il QDK moderno, è stato restituito il comportamento più rigoroso dell'applicazione di qubit per essere nello stato di terra in fase di rilascio. Questo consente agli autori dell'algoritmo di verificare il comportamento dell'algoritmo per la correttezza in preparazione dell'esecuzione sull'hardware.

Cancelli multicomposizione

Il QDK moderno usa ora strategie di scomposizione per i cancelli multi-controllati. Anche se questo non sfrutta i tasti di scelta rapida disponibili per la simulazione in cui i cancelli controllati da più fattori vengono facilmente implementati, corrisponde più strettamente al comportamento dei sistemi quantistici fisici. Ciò significa che l'esecuzione di un gate con un numero elevato di qubit di controllo comporta allocazioni qubit aggiuntive e cancelli di preparazione, allo stesso modo in cui verrà compilata per l'esecuzione in hardware. Per altre informazioni sugli algoritmi di scomposizione usati, vedere l'implementazione nella libreria standard.

Generazione di QIR

Il QDK moderno produce QIR generando la rappresentazione testuale di LLVM (.ll) anziché usare bitcode (.bc). La maggior parte targets degli strumenti che accettano bitcode può anche analizzare la LLVM testuale, inclusi gli strumenti come PyQIR e QIR Runner.

Il QDK moderno è attualmente limitato alla generazione di QIR per i programmi compatibili con il profilo di base QIR. Quando la compilazione del profilo di base è configurata, il compilatore e l'estensione VSCode generano errori per i modelli che non sono compatibili con .target Il compilatore può anche ignorare in modo condizionale la compilazione di elementi con attributi che indicano che sono specifici per la compilazione targetsspecifica:

@Config(Unrestricted)
function ResultAsBool(input : Result) : Bool {
    input == One
}