Comment visualiser des diagrammes de circuits quantiques avec Q#

Les diagrammes de circuits quantiques sont une représentation visuelle des opérations quantiques. Ils montrent le flux de qubits par le biais du programme quantique, y compris les portes et les mesures appliquées à eux.

Dans cet article, vous allez apprendre à représenter visuellement des algorithmes quantiques avec des diagrammes de circuits quantiques à l’aide de Visual Studio Code ou jupyter Notebooks.

Pour plus d’informations sur les conventions de diagramme de circuit quantique, consultez conventions de circuits quantiques.

Prérequis

Code Visual Studio

• La dernière version de Visual Studio Code ou ouvrir VS Code sur le web.

• La dernière version de l’extension Kit de développement Azure Quantum.

• Les derniers packages Azure Quantum qsharp et azure-quantum Python.

  python -m pip install --upgrade qsharp azure-quantum
  

Blocs-notes Jupyter

• La dernière version de Visual Studio Code ou ouvrir VS Code sur le web.

• VS Code avec les extensions Azure Quantum Development Kit, Python et Jupyter installées.

• Les derniers packages et qsharp-widgets Azure Quantumqsharp, ainsi que le ipykernel package.

  python -m pip install --upgrade qsharp qsharp-widgets ipykernel
  

Circuits quantiques avec Visual Studio Code

Suivez ces étapes pour visualiser les circuits quantiques de Q# programmes dans Visual Studio Code. Pour plus d’informations sur les conventions de diagramme de circuit quantique, consultez conventions de circuits quantiques.

Affichage des diagrammes de circuit pour un Q# programme

1. Ouvrez un Q# fichier dans Visual Studio Code ou chargez l’un des exemples quantiques.

2. Pour visualiser le circuit quantique du Q# programme, sélectionnez Affichage -> Palette de commandes et tapez « circuit » qui doit afficher l’option : Afficher le Q#circuit . Vous pouvez également cliquer sur Circuit dans la liste des commandes précédentes Main().

   

3. Le circuit s’affiche dans la fenêtre du Q# circuit. Par exemple, le circuit suivant correspond à une opération qui place un qubit dans une superposition, puis la mesure. Le diagramme de circuit montre un registre qubit initialisé à l’état |0⟩. Ensuite, une porte Hadamard, H, est appliquée au qubit, suivie d’une opération de mesure, représentée par un symbole de compteur.

   

Affichage des diagrammes de circuit pour les opérations

Vous pouvez visualiser le circuit quantique pour une seule Q# opération. Pour ce faire, cliquez sur le bouton Circuit dans l’objectif de code qui apparaît au-dessus de la déclaration d’opération.

Affichage des diagrammes de circuit lors du débogage

Lors du débogage d’un Q# programme, vous pouvez visualiser le circuit quantique en fonction de l’état actuel du programme.

1. Sélectionnez le bouton Déboguer dans la liste des commandes de l’objectif de code précédentes Main().

2. Dans la vue Exécuter et déboguer sur le côté gauche, développez la section Circuit quantique dans le volet Variables pour afficher le circuit à mesure que vous parcourez le programme.

   

3. Vous pouvez parcourir le code et définir des points d’arrêt dans différents points pour voir la mise à jour du circuit à mesure que le programme est exécuté.

4. Le circuit quantique actuel est affiché dans le Q# panneau Circuit. Ce diagramme de circuit représente l’état actuel du simulateur, c’est-à-dire les portes qui ont été appliquées jusqu’au point d’exécution actuel.

   

Circuits quantiques avec des notebooks Jupyter

Dans Jupyter Notebooks, vous pouvez visualiser des circuits quantiques à l’aide du qsharp-widgets package. Ce package fournit un widget qui affiche un diagramme de circuit quantique en tant qu’image SVG.

1. Dans Visual Studio Code, sélectionnez Affichage > Palette de commandes, puis sélectionnez Créer : Notebook Jupyter.

2. Dans la première cellule du notebook, exécutez le code suivant pour importer le Q# module.

   import qsharp
   

3. Ajoutez une nouvelle cellule et entrez le Q# code. Par exemple, le code suivant prépare un état Bell.

   %%qsharp
   
   // Prepare a Bell State.
   use register = Qubit[2];
   H(register[0]);
   CNOT(register[0], register[1]);
   

4. Vous pouvez utiliser la dump_circuit() fonction pour afficher un circuit quantique en fonction de l’état actuel du programme. Par exemple, le diagramme de circuit montre deux registres qubits qui sont initialisés à l’état |0⟩. Ensuite, une porte Hadamard, H, est appliquée au premier qubit. Après cela, une porte CNOT est appliquée à l’aide du premier qubit comme contrôle, qui est représenté en tant que point, et le deuxième qubit comme target, qui est représenté en tant que X.

   qsharp.dump_circuit()
   

   q_0    ── H ──── ● ──
   q_1    ───────── X ──
   

5. Vous pouvez visualiser des circuits quantiques en tant qu’image SVG à l’aide du qsharp-widgets package. Dans ce cas, la porte CNOT est représentée sous la forme d’une ligne reliant les deux qubits, avec un point sur le qubit de contrôle et une croix circonscrite sur le target qubit. Pour plus d’informations, consultez les conventions de circuits Quantum.

   from qsharp_widgets import Circuit
   
   Circuit(qsharp.dump_circuit())
   

   

Affichage des diagrammes de circuit pour une expression d’entrée

Vous pouvez générer un diagramme de circuit pour n’importe quel programme avec une expression d’entrée en appelant qsharp.circuit() et en passant l’expression d’entrée en tant qu’argument.

1. Par exemple, ajoutez une nouvelle cellule et copiez le code suivant, qui prépare un état GHZ.

   %%qsharp
   
   import Std.Diagnostics.*;
   import Std.Measurement.*;
   
   operation GHZSample(n: Int) : Result[] {
       use qs = Qubit[n];
   
       H(qs[0]);
       ApplyToEach(CNOT(qs[0], _), qs[1...]);
   
       let results = MeasureEachZ(qs);
       ResetAll(qs);
       return results;
   }
   

2. Ajoutez une nouvelle cellule et exécutez le code suivant pour visualiser le circuit. Par exemple, préparez un état GHZ avec 3 qubits.

   Circuit(qsharp.circuit("GHZSample(3)"))
   

Affichage des diagrammes de circuit pour les opérations avec des qubits

Vous pouvez générer des diagrammes de circuit pour toute opération qui prend des qubits ou des tableaux de qubits. Le diagramme montre autant de câbles qubits d’entrée, ainsi que tous les qubits supplémentaires alloués dans l’opération. Lorsque l’opération prend un tableau de qubits (Qubit[]), le circuit affiche le tableau sous la forme d’un registre de 2 qubits.

1. Ajoutez une nouvelle cellule et copiez l’exemple suivant. Ce code prépare un état de chat.

   %%qsharp
   
   operation PrepareCatState(register : Qubit[]) : Unit {
       H(register[0]);
       ApplyToEach(CNOT(register[0], _), register[1...]);
   }
   

2. Ajoutez une nouvelle cellule et exécutez le code suivant pour visualiser le circuit de l’opération PrepareCatState .

   Circuit(qsharp.circuit(operation="PrepareCatState"))
   

Conditions qui affectent les diagrammes de circuit

Lors de la visualisation des circuits quantiques, les conditions suivantes peuvent affecter la visualisation du diagramme de circuit.

Circuits dynamiques

Les diagrammes de circuit sont générés en exécutant toute la logique classique au sein d’un Q# programme et en effectuant le suivi des qubits qui ont été alloués ou des portes qui ont été appliquées. Les boucles et les conditions sont prises en charge tant qu’elles ne traitent que des valeurs classiques.

Toutefois, les programmes qui contiennent des boucles et des expressions conditionnelles qui utilisent des résultats de mesure qubit sont plus difficiles à représenter avec un diagramme de circuit. Par exemple, une expression comme celle-ci

if (M(q) == One) {
   X(q)
}

ne peut pas être représenté avec un diagramme de circuit simple, car les portes sont conditionnelles à un résultat de mesure. Un tel circuit est appelé circuit dynamique .

Les diagrammes de circuit peuvent être générés pour les circuits dynamiques en exécutant le programme dans le simulateur quantique et en traçant les portes à mesure qu’elles sont appliquées. Il s’agit du mode de trace , car les qubits et les portes sont suivis au fur et à mesure que la simulation est en cours d’exécution.

L’inconvénient des circuits tracés est qu’ils capturent uniquement le résultat de mesure, et les applications de porte qui en résultent, pour une seule simulation. Dans l’exemple ci-dessus, si le résultat de la mesure est Zero, vous ne voyez pas la X porte dans le diagramme. Une autre exécution de la simulation peut montrer un circuit légèrement différent.

Target profil

Le profil actuellement sélectionné target influence la façon dont les diagrammes de circuit sont générés. Target les profils sont utilisés pour spécifier les fonctionnalités du target matériel et les restrictions imposées au programme quantique.

Lorsque le target profil est défini sur Ri adaptatif sans restriction ou QIR, les diagrammes de circuit affichent les opérations quantiques appelées dans le Q# programme. Lorsque le target profil est défini sur la base QIR, les diagrammes de circuit affichent les opérations quantiques qui seraient exécutées sur du matériel si le programme est soumis à Azure Quantum avec ce target profil.

Plus précisément, les décompositions de porte sont appliquées pour rendre le circuit résultant compatible avec les fonctionnalités du target matériel. Il s’agit des mêmes décompositions qui seraient appliquées pendant la génération et la soumission de code à Azure Quantum.

1. Par exemple, considérez le programme suivant Q# qui mesure un qubit et un tableau de qubits.

   import Std.Measurement.*;
   
   operation Main() : (Result, Result[]) {
       // The `M` operation performs a measurement of a single qubit in the
       // computational basis, also known as the Pauli Z basis.
       use q = Qubit();
       let result = M(q);
       Reset(q);
   
       // The `MeasureEachZ` operation measures each qubit in an array in the
       // computational basis and returns an array of `Result` values.
       use qs = Qubit[2];
       let results = MeasureEachZ(qs);
   
       return (result, results);
   }
   

2. Lorsque target le profil est défini sur Ri adaptatif sans restriction ou QIR, les portes affichées sur le circuit correspondent exactement aux opérations quantiques appelées dans le Q# programme.

   

3. Lorsque le target profil est une base QIR, le circuit semble différent. Étant donné que le profil targets de base n’autorise pas la réutilisation du qubit après la mesure, la mesure est désormais effectuée sur un qubit inanglé à la place. Étant donné que Reset l’opération n’est pas une porte prise en charge dans le profil de base, elle est supprimée. Le circuit résultant correspond à ce qui serait exécuté sur le matériel si ce programme est soumis à Azure Quantum avec ce target profil.