Hantering av kvantminne

Ett program startar alltid utan kvantbitar, vilket innebär att du inte kan skicka värden av typen Qubit som startpunktsargument. Den här begränsningen är avsiktlig eftersom syftet med Q# är att uttrycka och resonera om ett program i sin helhet. I stället allokerar och släpper ett program kvantbitar, eller kvantminne, alltefter som det går. I det här avseendet Q# modellerar kvantdatorn som en qubit-heap.

I stället för att stödja separata allokerings- och versionsinstruktioner för kvantminne har Q# stöd för kvantminnesallokering i form av blockinstruktioner, där minnet endast är tillgängligt inom omfånget för den blockinstruktionen. Instruktionsblocket kan definieras implicit när kvantbitar allokeras under den aktuella omfattningens varaktighet, enligt beskrivningen i mer detaljerad information i avsnitten use om - och borrow -instruktionerna. Försök att komma åt de allokerade kvantbitarna när instruktionen avslutas resulterar i ett körningsundantag.

Q# har två instruktioner, use och borrow, som instansierar kvantbitsvärden, matriser med kvantbitar eller någon kombination av dessa. Du kan bara använda dessa instruktioner i åtgärder. De samlar in instansierade kvantbitsvärden, binder dem till variablerna som anges i -instruktionen och kör sedan ett block med instruktioner. I slutet av blocket hamnar de bundna variablerna utanför omfånget och definieras inte längre.

Q# skiljer mellan fördelningen av rena och smutsiga kvantbitar. Rena qubitar är oflätade och används inte av någon annan del av beräkningen. Smutsiga kvantbitar är kvantbitar vars tillstånd är okänt och kan till och med vara sammanflätat med andra delar av kvantprocessorns minne.

Använda -instruktion

Rena kvantbitar allokeras av -instruktionen use .

• -instruktionen består av nyckelordet use följt av en bindning och ett valfritt instruktionsblock.
• Om det finns ett instruktionsblock är kvantbitarna endast tillgängliga i det blocket. Annars är kvantbitarna tillgängliga till slutet av det aktuella omfånget.
• Bindningen följer samma mönster som let -uttryck: antingen en enda symbol eller en tuppel med symboler, följt av ett likhetstecken =, och antingen en enda tuppel eller en matchande tuppel med initialiserare.

Initiatorer är tillgängliga antingen för en enda qubit, som anges som Qubit(), eller en matris med kvantbitar, Qubit[n], där n är ett Int uttryck. Exempel:

use qubit = Qubit();
// ...

use (aux, register) = (Qubit(), Qubit[5]);
// ...

use qubit = Qubit() {
    // ...
}

use (aux, register) = (Qubit(), Qubit[5]) {
    // ...
}

Kvantbitarna är garanterat i ett |0⟩ tillstånd vid allokering. De släpps i slutet av omfånget och måste vara i ett |0⟩ tillstånd när de släpps. Det här kravet tillämpas inte av kompilatorn eftersom detta kräver en symbolisk utvärdering som snabbt blir oöverkomligt dyr. När du kör på simulatorer kan kravet framtvingas. På kvantprocessorer kan kravet inte köras. en oupplöslig kvantbit kan återställas till |0⟩ via en enhetlig transformering. Om du inte gör det resulterar det i ett felaktigt beteende.

- use instruktionen allokerar kvantbitarna från kvantprocessorns kostnadsfria qubit-heap och returnerar dem till heapen senast i slutet av det omfång där kvantbitarna är bundna.

Låneutdrag

-instruktionen borrow ger åtkomst till kvantbitar som redan har allokerats men som inte används för närvarande. Dessa kvantbitar kan vara i ett godtyckligt tillstånd och måste vara i samma tillstånd igen när låneutdraget avslutas. Vissa kvantalgoritmer kan använda kvantbitar utan att förlita sig på deras exakta tillstånd, och utan att kräva att de är osammanslagna med resten av systemet. Det vill säga de kräver extra kvantbitar tillfälligt, men de kan se till att dessa kvantbitar returneras exakt till sitt ursprungliga tillstånd, oberoende av vilket tillstånd det var.

Om det finns kvantbitar som används men inte rörs under delar av en subrutin, kan dessa kvantbitar lånas för användning av en sådan algoritm i stället för att allokera ytterligare kvantminne. Att låna i stället för att allokera kan avsevärt minska de övergripande kvantminneskraven för en algoritm och är ett kvantexempel på en typisk rymdtidsavvägning.

En borrow instruktion följer samma mönster som beskrevs tidigare för -instruktionenuse, där samma initierare är tillgängliga. Exempel:

borrow qubit = Qubit();
// ...

borrow (aux, register) = (Qubit(), Qubit[5]);
// ...

borrow qubit = Qubit() {
    // ...
}

borrow (aux, register) = (Qubit(), Qubit[5]) {
    // ...
}

De lånade kvantbitarna är i ett okänt tillstånd och går utanför omfånget i slutet av instruktionsblocket. Låntagaren åtar sig att lämna kvantbitarna i samma tillstånd som när de lånades; Det vill säga deras tillstånd i början och slutet av instruktionsblocket förväntas vara detsamma.

-instruktionen borrow hämtar använda kvantbitar som garanterat inte kommer att användas av programmet från den tidpunkt då kvantbiten är bunden till den senaste användningen av den kvantbiten. Om det inte finns tillräckligt med kvantbitar att låna allokeras kvantbitar från och returneras till heapen som en use instruktion.

Anteckning

Bland de kända användningsfallen för smutsiga kvantbitar finns implementeringar av flerkontrollerade CNOT-portar som kräver mycket få kvantbitar och implementeringar av inkrementer. Det här dokumentet om factoring med kvantbitar är ett exempel på en algoritm som använder lånade kvantbitar.