Le langage Q# et son utilisation

1. Introduction

Q# (« Q Sharp ») est le langage de programmation inventé par Microsoft et dédié à l’informatique quantique. Il peut s’exécuter sur des machines quantiques ou sur des simulateurs quantiques. Il est sorti en 2017 dans sa version 0.1. Il est présenté dans la documentation officielle comme un langage évolutif et multiparadigme.

2. Un langage évolutif

Il est évolutif en premier lieu, car il est sujet à des évolutions syntaxiques majeures, au moins tant qu’il n’a pas atteint la version 1.0. La dernière version du langage, lors de l’écriture de ce livre, date de fin octobre 2018 et correspond à la version 0.3.

Dans la documentation officielle, il est présenté comme évolutif pour une seconde raison : il peut être utilisé sur de très petites machines quantiques de quelques bits quantiques, tout comme sur d’énormes machines qui compteront peut-être un jour des milliers de bits quantiques, voire beaucoup plus.

3. Un langage multiparadigme

En programmation informatique, un paradigme de programmation correspond à la « philosophie » de codage associée au langage considéré. Il existe plusieurs paradigmes de programmation, en particulier la programmation impérative...

1. Contexte

La documentation officielle du langage précise que depuis la version 0.3 (fin octobre 2018), les programmeurs du langage Q# cherchent absolument à clarifier l’usage de certains signes comme la virgule ou le point-virgule dans le langage. En effet, il pouvait arriver que ces signes de ponctuation voient leurs significations changer selon le contexte ce qui entretenait une certaine ambiguïté.

2. Nomenclature relative aux signes de ponctuation

Depuis la version 0.3, le sens donné à chaque signe de ponctuation en Q# n’est plus soumis au contexte et est supposé être toujours le même. Concrètement, on a la nomenclature suivante :

Le deux-points n’est donc pas utilisable dans les ternaires comme en C# par exemple. Pour cet usage, on utilise le signe Pipe « | » :

En C# :

bool chaud = (température >= 25) ? true  : false;...

1. Les types primitifs du langage

Plusieurs types primitifs sont disponibles en Q# :

1. Introduction

On distingue plusieurs structures de données en Q# et plus généralement plusieurs types de conteneurs à même de stocker une information structurée. Il s’agit notamment des tableaux et des tuples que la présente partie se propose de détailler.

2. Le tableau

Cette structure de données utilise les caractères crochets, ([]) un peu sur le modèle d’autres langages comme le C#. Ainsi, l’exemple suivant correspond à un tableau de bits quantiques à une dimension :

Qubit[] 

Comme dans d’autres langages et comme dans l’exemple de téléportation abordé dans le chapitre précédent, on peut donner une taille à ce tableau. Ci-dessous un registre de deux bits quantiques :

Qubit[2] 

On peut également définir des tableaux multidimensionnels par exemple de dimension deux, comme ci-dessous :

Qubit[][] 

3. Le tuple

Un tuple est selon le Wiktionnaire dans sa définition au 14 novembre 2018, une « collection ordonnée de valeurs d’un nombre indéfini d’attributs relatifs à un même objet ». C’est exactement cette approche qu’il faut retenir pour envisager ce que sont les tuples dans le langage Q#.

On utilise pour définir un tuple les parenthèses et la virgule comme séparateur....

1. Définir ses propres types en Q#

Un mot-clé permet de créer de nouveaux types en Q#. Il s’agit du mot-clé newType. On peut l’utiliser ainsi, au sein d’un tuple par exemple :

newtype monType = (Int, Qubit); 

Ce type monType permet de créer des instances associant un Int et un Qubit. Le support de ce type est un tuple : ce nouveau type sera donc immutable. C’est-à-dire qu’une fois l’instance créée on ne pourra pas la modifier.

À noter qu’il faut évidemment se méfier des références circulaires dans la création des types. Le code suivant entraîne irrémédiablement une erreur de compilation :

newtype monType = (Int, monType_2); 
newtype monType_2 = (Qubit, monType); 

Ces types définis par l’utilisateur sont concernés par un important changement de la version 0.3. En effet, et jusqu’à cette version, un type utilisateur était un type à part entière sans spécificité. Depuis la version 0.3 incluse, un type utilisateur est un type encapsulé (wrapped). Un nouveau symbole est lié à ces types encapsulés qui permet de les désencapsuler (unwraped). Cette nouveauté de la version 0.3 du langage fait entièrement l’objet...

1. Distinction entre opération et fonction en Q#

Les deux notions peuvent être vues comme des sous-programmes. La différence se situe au niveau même des actions réalisées par ces sous-programmes :

Schématiquement :

En termes de vocabulaire, opérations et fonctions sont regroupées dans une famille nommée callables (« appelables » en français).

2. Utiliser des « callables » dans des « callables »

Précisons l’écriture des signatures de ces callables quand elles sont utilisées « inline », c’est-à-dire dans la définition d’une autre callable.

Les deux séquences de caractères qui sont utilisées pour cela sont :

La première est utilisée pour les opérations et la seconde pour les fonctions.

Par exemple, voici la signature d’une opération dans laquelle apparaissent les entrées et les sorties :

((Qubit, Pauli) => Result) 

L’exemple suivant, d’une signature d’opération, est directement issue de l’exemple fourni par Microsoft (issu du fichier MultiControlledNOTTests.qs) et met en évidence l’usage de => :

operation ControlledTestHelper (op : ((Qubit[], Qubit) => 
Unit : Adjoint), target : Qubit[]) : Unit 

L’opération ControlledTestHelper prend en entrée un tuple composé d’une opération op et d’un registre de bits quantiques target. Sa sortie est un tuple vide de type Unit.

Prenons à présent un exemple...

1. Le mot-clé let et l’immutabilité

Le mot-clé let permet de définir une variable immutable qui va être une variable locale. C’est-à-dire qu’elle a une consistance dans le scope courant, que ce soit le corps (body) d’une opération ou encore dans une boucle for par exemple.

Dans l’exemple suivant, on déclare un tableau de portes quantiques. En l’occurrence, la collection des portes de Pauli (X, Y, Z et identité) :

let pauliGates = [PauliX, PauliY, PauliX, PauliI]; 

Il n’y a donc pas de typage explicite avec let : c’est le compilateur qui gère le type selon la valeur affectée.

2. Les mots-clés mutable et set

Se pose donc la question de la création de variables locales qui seraient mutables et donc modifiables a posteriori. Pour répondre à ce besoin le langage Q# offre un mot-clé mutable qui permet de créer une variable mutable par la suite modifiable grâce au mot-clé set.

Dans le code suivant, on déclare une fonction qui prend en paramètre un entier taille. On souhaite allouer un tableau d’entiers. Dans chaque case du tableau, on désire stocker le carré de l’index de la case.

Si taille = 6 : on désire renvoyer le tableau [ 0, 1, 4, 9, 16, 25].

Si on crée le tableau avec let, il sera immutable et on ne pourra...

1. Utiliser un registre de bits quantiques

Comme nous l’avons entraperçu plus tôt, il est d’usage d’utiliser using pour créer et utiliser en mémoire un registre de bits quantiques. Dans l’exemple suivant, on utilise un registre de trois bits quantiques :

using (register = Qubit[3]) { 
   // On fait quelque-chose 
} 

Lorsqu’il est initialisé, un bit quantique est à la valeur c’est-à-dire le vecteur (1 0) ou exprimé en Q# la valeur Zero (par opposition à One). Ici, l’initialisation correspond à quelque-chose qui peut s’écrire , c’est-à-dire que chaque bit quantique qui compose le registre est à la valeur Zero et donc représenté par le vecteur (1 0).

2. Première approche des portes quantiques en Q#

operation PreparationRegistre(bitstring : Bool[], registre : 
Qubit[]) : Unit { 
   body (...) { 
       let taille = Length(registre); 
       for (ii in 0..taille - 1) { 
           if (bitstring[ii]) { 
               X(registre[ii]); 
           } 
       } 
   } 
   adjoint auto; 
   controlled auto; 
   controlled adjoint auto; 
} ...

1. Les tests unitaires en Q#

dotnet new xunit -lang Q 

cd Tests 

code . 

d. Écrire des tests unitaires

À ce stade, et quel que soit votre environnement de développement, votre solution inclut un projet de tests qui lui-même inclut deux fichiers, le premier d’extension Q# et le second d’extension C# :

1.	Tests.qs
2.	TestSuiteRunner.cs

Schématiquement, le premier fichier (.qs) va inclure les tests unitaires. Le second fichier (.cs) permet d’exécuter les tests du premier et d’en tirer un rapport de tests par exemple.

Le fichier Tests.qs contient un premier test unitaire d’exemple nommé AllocateQubitTest qui consiste à vérifier qu’un bit quantique tout juste créé est effectivement disponible avec un état quantique équivalent à .

operation AllocateQubitTest () : Unit 
{ 
   body (...) 
   { 
       using (qs = Qubit())  
       { 
           Assert([PauliZ], [qs], Zero, "Newly allocated qubit must...

1. Contexte

Les espaces de noms composant le Microsoft Quantum Development Kit ont été évoqués à plusieurs reprises dans le présent chapitre. Il s’agit à présent de préciser le rôle et le contenu des principaux espaces de noms de la solution quantique de Microsoft.

2. L’espace de noms Microsoft.Quantum.Core

L’espace de noms inclut les principales fonctions qui permettent de manipuler des structures de données et notamment les énumérations de type Range. Par exemple, les fonctions suivantes :

3. Les espaces Microsoft.Extensions.*

Microsoft.Extensions inclut les espaces de noms suivants :