Gestion de la mémoire quantique

Un programme démarre toujours sans qubits, ce qui signifie que vous ne pouvez pas passer des valeurs de type Qubit en tant qu’arguments de point d’entrée. Cette restriction est intentionnelle puisque l’objectif de Q# est d’exprimer et de raisonner sur un programme dans son intégralité. Au lieu de cela, un programme alloue et libère des qubits, ou de la mémoire quantique, comme il se passe. À cet égard, Q# modélise l’ordinateur quantique en tant que tas qubit.

Au lieu de prendre en charge des instructions de et de de mise en production distinctes pour la mémoire quantique, Q# prend en charge l’allocation de mémoire quantique sous la forme d’instructions de bloc , où la mémoire est accessible uniquement dans l’étendue de cette instruction de bloc. Le bloc d’instructions peut être implicitement défini lors de l’allocation de qubits pour la durée de l’étendue actuelle, comme décrit plus en détail dans les sections relatives aux instructions use et borrow. Toute tentative d’accès aux qubits alloués après la fin de l’instruction entraîne une exception d’exécution.

Q# a deux instructions, use et borrow, qui instancient des valeurs de qubits, des tableaux de qubits ou toute combinaison de ces derniers. Vous ne pouvez utiliser ces instructions que dans les opérations. Ils rassemblent les valeurs qubit instanciées, les lient aux variables spécifiées dans l’instruction, puis exécutent un bloc d’instructions. À la fin du bloc, les variables liées sortent de l’étendue et ne sont plus définies.

Q# distingue l’allocation de propre et qubits sales. Les qubits propres sont nonanglés et ne sont pas utilisés par une autre partie du calcul. Les qubits sales sont des qubits dont l’état est inconnu et qui peuvent même être enchevêtrés avec d’autres parties de la mémoire du processeur quantique.

Instruction Use

Les qubits propres sont alloués par l’instruction use.

• L’instruction se compose du mot clé use suivi d’une liaison et d’un bloc d’instructions facultatif.
• Si un bloc d’instructions est présent, les qubits sont disponibles uniquement dans ce bloc. Sinon, les qubits sont disponibles jusqu’à la fin de l’étendue actuelle.
• La liaison suit le même modèle que les instructions let : un symbole unique ou un tuple de symboles, suivi d’un signe égal =, et d’un tuple unique ou d’un tuple correspondant de initialiseurs.

Les initialiseurs sont disponibles pour un qubit unique, indiqué comme Qubit(), ou un tableau de qubits, Qubit[n], où n est une expression Int. Par exemple

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

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

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

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

Les qubits sont garantis dans un état |0⟩ lors de l’allocation. Ils sont libérés à la fin de l’étendue et doivent être dans un état |0⟩ lors de la mise en production. Cette exigence n’est pas appliquée par le compilateur, car cela nécessiterait une évaluation symbolique qui devient rapidement coûteuse. Lors de l’exécution sur des simulateurs, l’exigence peut être appliquée au moment de l’exécution. Sur les processeurs quantiques, l’exigence ne peut pas être appliquée au moment de l’exécution ; un qubit non mesuré peut être réinitialisé à |0⟩ via une transformation unitaire. L’échec de cette opération entraîne un comportement incorrect.

L’instruction use alloue les qubits du tas qubit libre du processeur quantique et les retourne au tas pas plus tard que la fin de l’étendue dans laquelle les qubits sont liés.

Instruction Borrow

L’instruction borrow accorde l’accès aux qubits déjà alloués, mais pas actuellement en cours d’utilisation. Ces qubits peuvent être dans un état arbitraire et doivent être à nouveau dans le même état lorsque l’instruction borrow se termine. Certains algorithmes quantiques peuvent utiliser des qubits sans compter sur leur état exact et sans exiger qu’ils soient inanglés avec le reste du système. Autrement dit, ils nécessitent temporairement des qubits supplémentaires, mais ils peuvent s’assurer que ces qubits sont retournés exactement à leur état d’origine, indépendamment de l’état qui était.

S’il existe des qubits qui sont utilisés mais qui ne sont pas touchés pendant des parties d’une sous-routine, ces qubits peuvent être empruntés pour être utilisés par un tel algorithme au lieu d’allouer de la mémoire quantique supplémentaire. L’emprunt au lieu d’allouer peut réduire considérablement les besoins globaux en mémoire quantique d’un algorithme et est un exemple quantique d’un compromis classique au moment de l’espace.

Une instruction borrow suit le même modèle décrit précédemment pour l’instruction use, avec les mêmes initialiseurs disponibles. Par exemple

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

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

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

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

Les qubits empruntés sont dans un état inconnu et sortent de l’étendue à la fin du bloc d’instructions. L’emprunteur s’engage à quitter les qubits dans le même état que lorsqu’ils ont été empruntés ; autrement dit, leur état au début et la fin du bloc d’instructions est censé être identique.

L’instruction borrow récupère des qubits en cours d’utilisation qui ne sont pas utilisés par le programme à partir du moment où le qubit est lié jusqu’à la dernière utilisation de ce qubit. S’il n’y a pas suffisamment de qubits disponibles pour emprunter, les qubits sont alloués et retournés au tas comme une instruction use.

Remarque

Parmi les cas d’usage connus des qubits sales, citons des implémentations de portes CNOT multicommandes qui nécessitent très peu de qubits et d’implémentations d’incrémentateurs. Ce document sur la factoring avec des qubits fournit un exemple d’algorithme qui utilise des qubits empruntés.