Représentation intermédiaire quantique

Article
06/09/2023

Quantum Intermediate Representation (QIR) est une représentation intermédiaire qui sert d’interface commune entre les langages/frameworks de programmation quantique et targetles plateformes de calcul quantiques. QIR spécifie un ensemble de règles pour représenter des programmes quantiques à l’aide d’un format indépendant du langage et du matériel dans LLVM IR. QIR est un projet développé par l’Alliance QIR dont Microsoft est l’un des membres.

Qu’est-ce qu’une représentation intermédiaire ?

Un modèle courant dans les compilateurs classiques consiste à commencer par compiler le langage source dans une représentation intermédiaire. Une représentation intermédiaire est, comme son nom l’indique, une étape intermédiaire dans la conversion d’instructions du code source en langage machine.

Une représentation intermédiaire agit comme une représentation abstraite d’un programme. Tous les programmes, quel que soit le langage dans lequel ils sont écrits, sont traduits dans cette représentation intermédiaire par un compilateur frontal, tandis qu’un composant back-end est chargé de traduire cette représentation intermédiaire en une représentation automatique. La représentation intermédiaire permet donc de dissocier les langages sources des plateformes matérielles et de créer un compilateur de manière modulaire, où chaque nouveau langage nécessite uniquement un nouveau serveur front-end pour être pris en charge sur toutes les plateformes pour lesquelles un back end est disponible.

La représentation intermédiaire est généralement conçue pour permettre à de nombreux langages sources différents d’être représentés. De plus, à ce niveau intermédiaire, il est également possible d’effectuer une optimisation et une réorganisation de circuit qui rend l’implémentation finale plus efficace. Une fois la plateforme d’exécution finale target connue, la représentation intermédiaire peut être compilée dans le code exécutable réel.

Cette approche permet à de nombreux langages sources de partager un ensemble commun d’optimiseurs et de générateurs exécutables. Il facilite également la compilation d’un langage source unique pour de nombreux .targets La représentation intermédiaire fournit une plateforme commune qui peut être partagée entre de nombreuses sources et targets permet une grande réutilisation dans les machines du compilateur.

Qu’est-ce que Quantum Intermediate Representation ?

QIR est une représentation intermédiaire pour les programmes quantiques développés par l’Alliance QIR, à laquelle Microsoft appartient. Il fournit une interface commune qui prend en charge de nombreux langages et target plateformes pour le calcul quantique. Vous pouvez considérer QIR comme un langage universel de couche intermédiaire qui permet la communication entre les langages de haut niveau et les machines. Bien que Q# compile en QIR, QIR n’est pas spécifique à Q# : n’importe quelle infrastructure de programmation quantique peut tirer parti de QIR pour représenter un programme quantique. Il est indépendant du matériel, ce qui signifie qu’il ne spécifie pas d’instruction quantique ou de jeu de portes, laissant cela à l’environnement target informatique.

QIR est basée sur le compilateur classique LLVM open source populaire. LLVM est une collection de technologies de compilateur et de chaîne d’outils modulaires et réutilisables qui ont été adaptées par un large éventail de langages. QIR spécifie un ensemble de règles pour représenter des constructions quantiques dans LLVM, mais ne nécessite aucune extension ni modification de LLVM.

Le fait que LLVM est la chaîne d’outils sous-jacente signifie que QIR est naturellement capable de traiter à la fois la logique classique et quantique. Cette fonctionnalité est essentielle pour les algorithmes quantiques hybrides classiques, qui sont devenus de plus en plus importants pour les applications de l’informatique quantique. En outre, elle vous permet de tirer parti des outils de compilation et d’optimisation du secteur de l’informatique classique et, par conséquent, de réduire le coût de l’écriture de traductions.

De nombreux secteurs de pointe de l’informatique quantique ont déjà adopté QIR. Par exemple, NVIDIA, Oak Ridge National Laboratory, Quantinuum, Quantum Circuits Inc. et Rigetti Computing créent des chaînes d’outils qui tirent parti de QIR.

Pour plus d’informations, consultez spécification QIR. Si vous êtes intéressé par les outils et projets du compilateur qui utilisent QIR, consultez ces dépôts QIR.

Qu’est-ce que l’Alliance QIR ?

L’Alliance QIR est un effort conjoint visant à développer une représentation quantique intermédiaire prospective dans le but de permettre une interopérabilité complète au sein de l’écosystème quantique, de réduire les efforts de développement de toutes les parties et de fournir une représentation adaptée aux processeurs quantiques hétérogènes actuels et futurs.

Les SDK et les langages quantiques apparaissent et évoluent à un rythme rapide, ainsi que de nouveaux processeurs quantiques avec des fonctionnalités uniques et distinctes les unes des autres. Pour assurer l’interopérabilité entre les nouveaux langages et les nouvelles fonctionnalités matérielles, il est impératif que l’écosystème développe et partage une représentation intermédiaire qui fonctionne avec le matériel quantique présent et futur.

Par son travail collectif et son partenariat, l’Alliance QIR vise à :

Réduire les efforts de développement requis pour toutes les parties en favorisant l’interopérabilité entre différents frameworks et langages.
Activer le développement de bibliothèques partagées à la fois pour le développement d’applications quantiques et pour le développement de compilateur quantique.
Tirer parti de la technologie de compilateur de pointe et des outils, bibliothèques et apprentissages existants du calcul hautes performances.
Autoriser l’évolution incrémentielle et progressive dans la façon dont les calculs classiques et quantiques peuvent interagir au niveau matériel.
Fournir la flexibilité nécessaire pour connecter facilement les technologies émergentes d’une manière qui permet l’expérimentation avec des fonctionnalités matérielles distinctes et différenciées.

L’Alliance QIR fait partie du travail de la Linux Foundation’s Joint Development Foundation sur les normes ouvertes. Les membres fondateurs incluent Microsoft, ainsi que Quantinuum (anciennement Honeywell), Oak Ridge National Laboratory, Quantum Circuits Inc. et Rigetti Computing.

À quoi Quantum Intermediate Representation ressemble ??

Étant donné que QIR est basé sur LLVM, QIR ressemble à LLVM.

Prenons comme exemple le code Q# suivant pour générer une paire Bell :

operation CreateBellPair(q1 : Qubit, q2 : Qubit) : Unit {
    H(q1);
    CNOT(q1, q2);
}

Lorsqu’il est compilé en QIR, cela devient :

define void @CreateBellPair__body(%Qubit* %q1, %Qubit* %q2) {
entry:
  call void @__quantum__qis__h(%Qubit* %q1)
  call void @__quantum__qis__cnot(%Qubit* %q1, %Qubit* %q2)
  ret void
}

Dans cet extrait de code, vous pouvez voir quelques fonctionnalités QIR :

Les opérations dans Q# (ou tout autre langage de programmation quantique) sont représentées par des fonctions LLVM.
Les qubits sont représentés sous forme de pointeurs vers un type de structure opaque nommé appelé %Qubit.

Bien que la QIR pour l’opération CreateBellPair soit très simple, QIR hérite de toutes les fonctionnalités de LLVM pour exprimer des boucles, des conditions et d’autres flux de contrôle complexes. QIR hérite également de la capacité de LLVM à exprimer un calcul classique arbitraire.

Pour plus d’informations, regardez la session développeur de Microsoft qui a été présentée pendant l’événement Q2B 2021.

Pourquoi est-ce Quantum Intermediate Representation important ?

QIR est un outil essentiel lors de l’exécution d’algorithmes quantiques sur du matériel réel. Mais les représentations intermédiaires peuvent jouer un rôle important même si vous souhaitez simplement développer des algorithmes à un niveau plus théorique.

Par exemple, une application activée par QIR consiste à utiliser le compilateur Clang, un front-end en langage C pour LLVM, pour compiler QIR en code machine exécutable pour un fichier classique target. Cela permet de créer facilement un simulateur en C ou C++ en implémentant les instructions quantiques, ce qui peut simplifier la création de simulateurs quantiques.

En outre, vous pouvez utiliser la représentation intermédiaire pour générer du code fourni ultérieurement en tant qu’entrée dans un simulateur quantique (au lieu d’un appareil réel) qui pourrait potentiellement utiliser un langage différent du code source. De cette façon, vous pouvez facilement comparer et évaluer différents langages ou simulateurs à l’aide d’une infrastructure commune.

En termes d’optimisation du code, il existe des étapes d’optimisation qui peuvent être effectuées au niveau intermédiaire qui peuvent rendre l’implémentation globale de l’algorithme plus efficace. L’examen de cette optimisation de votre code d’entrée peut vous aider à mieux comprendre où rendre les algorithmes plus efficaces et comment améliorer les langages de programmation quantique.

Une autre application consiste à utiliser l’infrastructure « pass » LLVM standard pour créer des optimiseurs de code quantique qui fonctionnent sur QIR. L’approche indépendante du langage et du matériel de QIR permet de réutiliser ces optimiseurs pour différents langages de calcul et plateformes informatiques sans effort.