La synthaxe Q# (partie 1)

Mon objectif d'ici ces trois prochaines semaines, est de maîtriser en surface le language de programmation Q#. Qui suis-je pour maîtriser un concept qui peut parfois paraître abstrait même pour les plus aguerris.

Mais il y a un début à tout ! Mon objectif à court terme est de savoir lire un code rédigé en Q#.  Pour ce faire, il faut alors apprendre la base : La synthaxe.

Opérations et Fonctions

Les opérations et les fonctions sont les unités de codes qui constituent la base d'un exécutable Q#. On peut faire le parrallèle avec les fonctions en python ou les méthodes statiques en C# ou Java.

Les opérations et les fonctions sont deux unités différentes et se distinguent l'unes d'elles par  la matière qui est traitée dans chacune d'elles.

Opérations

Une opérations est une sous-routine quantique. Une routine que l'on peut appeler, et qui contient des opérations quantiques. Les opérations quantiques effectuent des calculs sur des qubits et sont utilisées pour implémenter des algorithmes quantiques.

Fonctions

Une fonction Q# est une sous-routines classique qui peut être utilisée à l'intérieur d'un algorithme quantique. Elles peuvent contenir du code classique, mais aucune opération quantique. Ainsi une fonction ne peut ni allouer ni emprunter des qubits, et elles ne peuvent pas appeler des opérations quantiques mais peuvent cependant intéragir avec celles-ci en leur passant par exemple des opération en paramétres.
Les fonctions sont entièrement déterministes, ce qui signifie que les appeler avec les mêmes arguments produira, contrairement aux opérations, toujours le même résultat.

Voici un exemple d'une opération *RandomBit* qui contient une fonction *AddTwoIntegers* :

La structure d'un code Q# est très similaire aux structures auxquelles je me suis habitué au cours des 3 dernières années. On utilise les points virgules pour terminer une instruction, les acollades pour commencer et terminer des instructions. les doubles barres obliques pour commenter le code et la manière dont on appel les fonctions me font aussi rappeler Java et C#. Cet exemple souligne aussi la variété du typage. En effet toutes les variables, les arguments et les valeurs de retour doivent avoir un type associé.

Le typage

Q# prend en charge un ensemble familier de types classiques. Voyons ensemble les types qui sont pris en charges par Q#. 
On peut observer deux catégorie de typage dans le language.

1. Les types dit classiques comme :

• Int
• BigInt
• Bool
• Double
• Unit

2. Les types quantiques :

• Qubit
• Result
• Range
• Pauli

Je ne vais pas approfondir les types classiques, car ils sont déjà familiers pour moi.

Les types Quantiques

Qubit

Pour rappel, un qubit, ou quantum bit, est l'unité fondamentale d'information quantique. Contrairement dans les système classiques, un qubit peut exister dans une superposition de deux états (0 et 1). En Q#, le type de données représentant un qubit est simplement appelé Qubit.
On utilise une variable de type Qubit quand on veut exploiter les principes de la mécanique quantique pour effectuer des calculs comme la superposition ou l'intrication (Les qubits peuvent être intriqués, ce qui signifie que l'état d'un qubit peut dépendre de l'état d'un autre, même s'ils sont physiquement éloignés).

Result

Le type Result en Q# est utilisé pour représenter le résultat d'une mesure quantique. Lorsqu'un qubit est mesuré, il retourne l'une des deux valeurs possibles : 0 ou 1. Le type Result est un type enumératif (enum) qui encapsule ces deux valeurs.

Dans cette exemple, on mesure le Qubit qui a été initialié grâce à M. Puis retourne le résultat de la mesure sous la forme d'une valeur de type Result.

On pourrait se demander où réside la différence entre un retour booléen et un retour Result. Puisque expliqué comme je l'ai fais ci-dessus, on pourrait croire qu'on devrait s'attendre à une valeur 0 ou 1 pour un retour de type Result.
Mais ce n'est pas tout à fait ça ! La grosse différence réside dans le contexte de nature  probabiliste des mesures quantiques. Le type Result capture cette nature probabiliste en fournissant explicitement les résultats possibles (Zero ou One) sur un nombre de shots donné. Voyez plutôt dans cette image :

Ici voici à quoi ressemble le retour de type Result. Pour 82 shots donné, on nous donne les états possibibles du qubit dans la section Result. On a un résultat qui nous montre plusieurs état possibles contrairement au Booléen qui lui donne un seul résultat possible.

Range

En Q#, le type Range est utilisé pour représenter une plage d'indices entiers, souvent utilisée pour spécifier un sous-ensemble d'éléments dans une séquence (par exemple, un tableau ou une liste). Une plage est définie par son début, sa fin et son pas. Voici comment initialiser un range :

Bien que le type Range puisse être utilisé dans un contexte classique, il est souvent utilisé dans un contexte quantique pour spécifier des plages d'indices lors d'opérations sur des qubits.

Conclusion

Aujourd'hui on a vu les deux unités qui constituent la base dela structure d'un code en Q# : Les opérations et les fonctions. On a vu ce qui les différenciait. Et puis on a vu les différents typage des variables.

Dans la seconde parties, nous allons voir les opérations de Pauli,  comment manipuler les variables, les tuples, array et ranges.

Références

Learn quantum computing with Azure Quantum, https://quantum.microsoft.com/en-us/experience/quantum-coding (Page consultée le 1 mars 2024)

Type System,  https://learn.microsoft.com/en-us/azure/quantum/user-guide/language/typesystem/?view=qsharp-preview#primitive-types (Page consultée le 1 mars 2024)

Intro to Q#,  https://stem.mitre.org/quantum/software-tools/intro-qsharp.html#arrays (Page consultée le 1 mars 2024)

Microsoft Open Sources “Quantum Katas” To Teach You Quantum Computing For Free, https://fossbytes.com/microsoft-open-sources-quantum-katas-to-teach-you-quantum-computing-for-free/ (Page consultée le 1 mars 2024)