Wat is er nieuw in de Azure Quantum Development Kit (moderne QDK)

  • Artikel

De moderne QDK is de nieuwste versie van de Q#-taal en ontwikkelhulpprogramma's. Met een kleinere footprint en snellere prestaties is het een Visual Studio Code-extensie met één klik en biedt taalverbeteringen, geïntegreerde ondersteuning voor Python en Jupyter Notebook, nieuwe syntaxismarkering, ondersteuning voor foutopsporing, ondersteuning voor projecten met meerdere bestanden, foutberichten en geïntegreerde Azure-connectiviteit. Door de afhankelijkheden van de vorige klassieke QDK te elimineren, is deze nu echt platformonafhankelijk en wordt deze uitgevoerd op Windows, Mac, Linux en het web.

Visual Studio Code-integratie

De moderne QDK is nauw geïntegreerd in de ontwikkelomgeving van Visual Studio Code. Nieuwe functies omvatten:

  • Een nieuwe resource-estimator voor VS Code die u lokaal kunt uitvoeren zonder dat u een Azure-account nodig hebt
  • Een Q#-foutopsporingsprogramma voor geïntegreerde foutopsporing met onderbrekingspunten, steppen en weergave van lokale en kwantumvariabelen
  • Ondersteuning voor Q#-projecten met meerdere bestanden
  • Taalserververbeteringen met foutberichten, syntaxismarkering, codevoltooiingen, informatie over aanwijzen en naar definities gaan
  • Geïntegreerde Azure-werkruimteconnectiviteit en taakinzending
  • Een ingebouwde sparse (ruisvrije) simulator
  • Jupyter Notebook integratie met Q#-codering in cellen en syntaxismarkering
  • QIR-generatie voor Q#-programma's

Binnenkort beschikbaar

  • Geïntegreerde hybride computing met adaptief profiel wordt nog niet ondersteund met de moderne QDK. Als u hybride computingprojecten wilt uitvoeren, raadpleegt u Doorgaan met werken in de klassieke QDK.

Afgeschafte functies

  • Ondersteuning voor Visual Studio
  • Ondersteuning voor .NET-talen en -projecten
  • De IQ#-kernel- en magic-opdrachten voor Jupyter Notebooks. Zie Jupyter Notebook-integratie en Uw code migreren voor meer informatie over het gebruik van Q# en Jupyter Notebooks.

Q#-taalupdates

Omdat kwantumdetecties en -innovaties zich in een snel tempo blijven ontwikkelen, blijven de Q#-taal en de Azure Quantum Development Kit zich ontwikkelen om te voldoen aan de huidige en toekomstige kwantumontwikkelingsbehoeften. In de volgende secties worden de wijzigingen, updates en verbeteringen in de moderne QDK beschreven.

Updates voor taalsyntaxis

Op basis van expressies

De Q#-taal is nu gebaseerd op expressies in plaats van op instructie. Hierdoor kan de bestaande syntaxis opnieuw worden gebruikt, zoals het insluiten van een if-expressie in een andere expressie:

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

Impliciete retour

In het vorige voorbeeld wordt ook gebruikgemaakt van het gebruik van -instructies zonder een puntkomma aan het einde van een blok om een waarde uit dat blok te retourneren. Dit patroon kan worden gebruikt in plaats van expliciete retourexpressies in een aanroepbare:

function ReturnsThree() : Int {
    return 3;
}

function AlsoReturnsThree() : Int {
    3
}

Blokexpressies

Q# ondersteunt nu blokexpressies die meerdere regels, bereikvariabelen kunnen ordenen en een waarde kunnen retourneren:

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

Items als instructies

Items zoals newtype, operation, function en zelfs open kunnen nu worden weergegeven als -instructies binnen een lokaal bereik. Dit maakt het mogelijk om lokale helpertypen en aanroepbare functies te definiëren, evenals scoped includes. Een lokale helperfunctie kan bijvoorbeeld worden gedefinieerd net voordat deze nodig is:

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]
}

Zowel de functie SubOne als de open van de Microsoft.Quantum.Arrays naamruimte zijn gericht op de ShowDecrement functie en hebben geen invloed op code buiten die functie.

Schaduw van naam

Q# maakt het nu mogelijk om omgezette namen te schaduwen waar dit eerder niet was toegestaan. Dit maakt het eenvoudiger om code die namen van variabelen of aanroepbare namen bevat, opnieuw te gebruiken zonder dat er een veranderlijke variabele nodig is:

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

Expliciete typen voor lokale variabelen

Lokale variabelen kunnen nu expliciet worden getypt met dezelfde syntaxis als typen voor aanroepbare argumentdeclaraties:

let x : Int[] = [];

Expliciete typen zijn niet vereist, maar kunnen soms handig zijn bij het oplossen van dubbelzinnigheid van typen voor functies die algemene functies accepteren, zoals Length. Het vorige patroon voor het afhandelen van dit - het toevoegen van concrete typen aan een algemene functie-aanroep met syntaxis zoals Length<Int[]>([]); - wordt niet meer ondersteund.

Impliciete prelude voor naamruimte

Naamomzetting bevat nu een impliciete prelude. Dit is een set naamruimten die worden behandeld alsof ze zijn geopend, zolang er geen andere opgeloste namen deze vervangen. De naamruimten die op deze manier worden behandeld, zijn Microsoft.Quantum.Core, Microsoft.Quantum.Canonen Microsoft.Quantum.Intrinsic. Deze hoeven niet expliciet te worden geopend, behalve wanneer u aliassen gebruikt of anderszins onderscheid maakt van mogelijke conflicten.

Standaardbibliotheek

De Q#-standaardbibliotheek wordt nu gehost in dezelfde opslagplaats als de compiler en runtime en vindt u in de bibliotheekmap op het hoogste niveau. Niet alle functionaliteit en functies zijn gemigreerd vanuit de klassieke Q#-bibliotheken, die nog steeds toegankelijk zijn op https://github.com/microsoft/QuantumLibraries. Als een item uit de vorige bibliotheek nodig is voor een programma, kunnen dat item en eventuele afhankelijkheden worden gekopieerd naar het bronprogramma. Als een bibliotheekfunctionaliteit essentieel is voor een werkstroom en in overweging moet worden genomen voor opname in de nieuwe standaardbibliotheek, dient u een GitHub-probleem in met de details.

Simulatie

Sparse-simulatie standaard

De moderne QDK maakt gebruik van een ingebouwde sparse state kwantumsimulator als standaard target voor lokale simulatie. Deze simulator is geschreven in Rust en is afkomstig van de QIR Runner-opslagplaats , zodat deze kan worden gecompileerd naar WASM en kan worden uitgevoerd in verschillende omgevingen. Dit is momenteel de enige simulatie-back-end die beschikbaar is in de QDK, hoewel andere back-ends in overweging worden genomen voor toekomstige integratie. Zie Test large quantum algorithms using sparse simulation (Grote kwantumalgoritmen testen met sparse simulatie) voor meer informatie over het ontwerp van sparse simulatie.

Strengere controles op qubit-release

De klassieke QDK had in het verleden de vereiste dat qubits zich in de grond- of |0⟩ toestand bevinden voordat ze aan het einde van het bereik werden vrijgegeven, zodanig dat een qubit die is gemeten en niet verder wordt gebruikt, ook veilig was om vrij te geven omdat de simulator de qubit automatisch opnieuw zou instellen. Dit veroorzaakte echter verwarring wanneer hetzelfde programma werd uitgevoerd op echte kwantumhardware waar een dergelijke automatische reset niet aanwezig is en qubits opnieuw kunnen worden gebruikt in een onverwachte status. Voor de moderne QDK zijn we teruggekeerd naar het strengere gedrag van het afdwingen dat qubits bij het vrijgeven de grondstatus moeten hebben. Dit helpt auteurs van algoritmes om het gedrag van hun algoritme te controleren op juistheid bij de voorbereiding op uitvoering op hardware.

Uitgevouwen multi-gestuurde poorten

De moderne QDK maakt nu gebruik van ontledingsstrategieën voor poorten met meerdere controle. Hoewel dit geen gebruik maakt van snelkoppelingen die beschikbaar zijn voor simulatie, waarbij poorten met meerdere controlemogelijkheden eenvoudig kunnen worden geïmplementeerd, komt het wel nauwer overeen met het gedrag van fysieke kwantumsystemen. Dit betekent dat het uitvoeren van een gate met een groot aantal controle-qubits extra qubittoewijzingen en voorbereidingspoorten met zich meebrengt, op dezelfde manier als bij het compileren voor uitvoering op hardware. Zie de implementatie in de standaardbibliotheek voor meer informatie over de gebruikte ontledingsalgoritmen.

QIR-generatie

De moderne QDK produceert QIR door de tekstuele weergave van LLVM (.ll) te genereren in plaats van bitcode (.bc). De meeste targets hulpprogramma's en die bitcode accepteren, kunnen ook tekstuele LLVM parseren, inclusief hulpprogramma's zoals PyQIR en QIR Runner.

De moderne QDK is momenteel beperkt tot QIR-generatie voor programma's die compatibel zijn met het QIR-basisprofiel. Wanneer basisprofielcompilatie is geconfigureerd, produceren de compiler- en VSCode-extensie fouten voor patronen die niet compatibel zijn met de target. De compiler kan ook voorwaardelijk de compilatie overslaan van items die kenmerken hebben die aangeven dat ze specifiek zijn voor een bepaalde compilatie targets:

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