QuantumKatas

Avis de dépréciation

Nous modernisons l'expérience quantique Katas. Veuillez visiter https://quantum.microsoft.com/experence/quantum-katas pour essayer la nouvelle expérience en ligne Azure Quantum Katas, avec une assistance intégrée de Copilot in Azure Quantum.

Pour le référentiel QDK moderne, veuillez visiter Microsoft / Qsharp.

Pour plus d'informations sur le QDK et Azure Quantum modernes, visitez https://aka.ms/aq/documentation.

Introduction

Les katas quantiques sont une collection de tutoriels et d'exercices de programmation à votre rythme pour vous aider à apprendre l'informatique quantique et la programmation Q #.

Chaque kata est un ensemble distinct d'exercices qui comprend:

• Une séquence de tâches qui progressent de facile à dure. Chaque tâche vous oblige à remplir un code. La première tâche peut nécessiter une seule ligne, et la dernière peut nécessiter un code assez compliqué.
• Un cadre de test qui configure, exécute et valide vos solutions. Chaque tâche est couverte par un test unitaire qui échoue initialement. Une fois que vous avez écrit le code pour faire passer le test, vous pouvez passer à la tâche suivante.
• Liens vers l'informatique quantique et le matériel de référence Q # Vous pourriez avoir besoin de résoudre les tâches.
• Conseils, solutions de référence et explications détaillées pour vous aider si vous êtes coincé.

Les katas quantiques incluent également des tutoriels qui introduisent l'apprenant aux concepts et algorithmes de base utilisés dans l'informatique quantique, en commençant par les mathématiques nécessaires (nombres complexes et algèbre linéaire). Ils suivent le même modèle de complétation de la théorie par des démos Q # et des exercices de programmation pratiques.

Table des matières

• Chemin d'apprentissage
• Exécutez les katas et les tutoriels en ligne
• Exécutez les katas localement
  • Installation du kit de développement quantique
  • Téléchargez les katas quantiques
  • Exécutez un kata en tant que cahier Jupyter
  • Exécutez un Kata comme un projet Q #
  • Exécutez les tests Kata
  • Exécutez Katas localement avec Docker
• Contributif
• Code de conduite

Chemin d'apprentissage

Voici le chemin d'apprentissage que nous vous suggérons de suivre si vous commencez à apprendre l'informatique quantique et la programmation quantique. Une fois que vous êtes à l'aise avec les bases, vous êtes invités à sauter sur les sujets qui piquent votre intérêt!

Concepts informatiques quantiques: qubits et portes

• Arithmétique complexe (tutoriel) . Découvrez les nombres complexes et les mathématiques nécessaires pour travailler avec l'informatique quantique.
• Algèbre linéaire (tutoriel) . Découvrez les vecteurs et les matrices utilisés pour représenter les états quantiques et les opérations quantiques.
• Le qubit (tutoriel) . Apprenez ce qu'est un qubit.
• Portes à qubit (tutoriel) . Découvrez ce qu'est une porte quantique et sur les portes le plus courantes.
• Gates informatiques quantiques de base . Apprenez à appliquer les portes les plus courantes utilisées dans l'informatique quantique.
• Systèmes multi-qubit (tutoriel) . Apprenez à représenter des systèmes multi-qubit.
• Portes multi-qubit (tutoriel) . Découvrez les portes multi-qubit les plus courantes.
• Superposition . Apprenez à préparer des états de superposition.

Concepts informatiques quantiques: mesures

• Mesures de qubit (tutoriel) . Apprenez ce qu'est la mesure quantique et comment l'utiliser pour les systèmes à qubit unique.
• Mesures multi-qubit (tutoriel) . Apprenez à utiliser des mesures pour les systèmes multi-Qubit.
• Mesures . Apprenez à distinguer les états quantiques à l'aide de mesures.
• Distinguer les unitaires . Apprenez à distinguer les unitaires en concevant et en effectuant des expériences avec eux.
• Mesures conjointes . Découvrez l'utilisation des mesures conjointes (parité) pour distinguer les états quantiques et effectuer des transformations d'état.

Outils de kit de développement quantique Q # et Microsoft

• Outils de visualisation (tutoriel) . Apprenez à utiliser les différents outils pour visualiser les éléments des programmes Q #.

Algorithmes simples

• Génération de nombres aléatoires (tutoriel) . Apprenez à générer des nombres aléatoires en utilisant les principes de l'informatique quantique.
• Téléportation . Mettre en œuvre le protocole de téléportation standard et ses variations.
• Codage super . Implémentez le protocole de codage SuperDense.

Oracles quantiques et algorithmes d'oracle simples

• Oracles quantiques (tutoriel) . Apprenez à mettre en œuvre des fonctions classiques comme des oracles quantiques équivalents.
• Marquer des oracles . Pratiquez la mise en œuvre des oracles de marquage pour une variété de fonctions classiques.
• Exploration des algorithmes Deutsch et Deutsch - Jozsa (tutoriel) . Apprenez à implémenter des fonctions classiques et des oracles quantiques équivalents et comparez la solution quantique au problème Deutsch - Jozsa à un problème classique.
• Algorithme Deutsch - Jozsa . Découvrez les oracles quantiques qui implémentent les fonctions classiques et implémentez les algorithmes Bernstein - Vazirani et Deutsch - Jozsa.
• L'algorithme de Simon . Découvrez l'algorithme de Simon.

Algorithme de recherche de Grover

• Implémentation de l'algorithme de Grover . Découvrez l'algorithme de recherche de Grover et comment écrire des oracles quantiques à utiliser avec.
• Exploration de l'algorithme de recherche de Grover (tutoriel) . En savoir plus sur l'algorithme de recherche de Grover, en ramassant où l'algorithme de Grover Kata s'est arrêté.
• Résoudre les problèmes SAT en utilisant l'algorithme de Grover . Explorez l'algorithme de recherche de Grover, en utilisant les problèmes SAT comme exemple. Apprenez à implémenter des oracles quantiques en fonction de la description du problème au lieu d'une réponse à code dur. Utilisez l'algorithme de Grover pour résoudre des problèmes avec un nombre inconnu de solutions.
• Résoudre les problèmes de coloriage du graphique à l'aide de l'algorithme de Grover . Continuez l'exploration de l'algorithme de recherche de Grover, en utilisant des problèmes de coloriage graphique comme exemple.
• Résoudre un problème de sac à dos bordé à l'aide de l'algorithme de Grover . Découvrez comment résoudre les variantes du problème de sac à dos avec la recherche de Grover.

Outils et bibliothèques / construire à l'algorithme de Shor

• Transformée de Fourier quantique . Apprenez à implémenter Quantum Fourier Transform et à l'utiliser pour effectuer des transformations d'état simples.
• Estimation de phase . Découvrez les algorithmes d'estimation de phase.

Jeux enchevêtrés

• Jeu CHSH .
• Jeu ghz .
• Game Mermin-PERES Magic Square .

Informatique réversible

• Tables de vérité . Apprenez à représenter et à manipuler les fonctions booléennes comme des tables de vérité et à les implémenter en tant qu'opérations quantiques.
• Adder-Carry Ripple . Construisez un additionneur de voiture d'ondulation sur un ordinateur quantique.

Divers

• Protocole BB84 . Implémentez l'algorithme de distribution de clés BB84.
• Bit-flip Erreur de correction du code . Découvrez un code de correction d'erreurs de 3 qubit pour protéger contre les erreurs de flip bit.
• Schémas unitaires . Apprenez à implémenter des unitaires avec des matrices qui suivent certains modèles d'éléments nuls et non nuls.
• Classification quantique (tutoriel) . Découvrez les classificateurs centrés sur les circuits et la bibliothèque d'apprentissage automatique quantique incluse dans le QDK.

Pour une feuille de référence rapide du langage de programmation Q #, voir la référence rapide du langage Q #.

Exécutez les katas et les tutoriels en ligne

Les katas quantiques sont désormais disponibles sous forme de carnets de jupyter en ligne! Voir index.ipynb pour la liste de tous les katas et tutoriels, et des instructions pour les exécuter en ligne.

Notez que MyBinder.org fonctionne avec une capacité réduite, donc obtenir une machine virtuelle et lancer les ordinateurs portables peut prendre plusieurs tentatives. Bien que l'exécution de Katas en ligne soit l'option la plus simple pour commencer, si vous souhaitez économiser vos progrès et profiter de meilleures performances, nous vous recommandons de choisir l'option de configuration locale.

Exécutez les katas localement

Installation du kit de développement quantique

Pour utiliser les katas quantiques localement, vous aurez besoin du kit de développement quantique, disponible pour Windows 10, MacOS et Linux. Si vous n'avez pas déjà installé le kit de développement quantique, consultez le guide d'installation du kit de développement quantique.

Si vous souhaitez exécuter les katas et les tutoriels localement en tant que cahiers Jupyter :

1. Suivez les étapes du Guide d'installation QDK pour Python et le Guide d'installation QDK pour Jupyter Notebooks.
2. Plusieurs tutoriels nécessitent l'installation de packages Python supplémentaires:
   • "Arithmétique complexe" et "algèbre linéaire" nécessitent le package pytest .
   • "L'exploration de l'algorithme de recherche de Grover" nécessite le package matplotlib .
   • "Classification quantique" nécessite des packages matplotlib et numpy .

Reportez-vous à la mise à jour du noyau IQ # pour la mise à jour du noyau IQ # vers une nouvelle version avec des versions QDK mensuelles.

Si vous souhaitez exécuter les katas et les tutoriels localement comme des projets Q # :

Suivez les étapes du Guide d'installation QDK pour Visual Studio, Visual Studio Code ou d'autres éditeurs.

L'exécution des projets Q # des Katas localement nécessite le téléchargement et l'installation du SDK .NET 6.0. Vous pouvez le faire même si une autre version .NET est installée, car plusieurs versions sont prises en charge côte à côte.

Étant donné que Visual Studio 2019 ne prend pas en charge les projets .NET 6.0, vous devrez passer à Visual Studio 2022 et installer l'extension du kit de développement quantique Microsoft correspondant.

Téléchargez les katas quantiques

Si vous avez installé Git, clonez le référentiel Microsoft / Quantumkatas:

$ git clone https://github.com/Microsoft/QuantumKatas.git

CONSEIL
Visual Studio 2022 et Visual Studio Code facilitent la clonation des référentiels à partir de votre environnement de développement. Pour plus de détails, consultez la documentation du code Visual Studio et Visual Studio.

Si vous n'avez pas installé Git, téléchargez les katas à partir de https://github.com/microsoft/quantumkatas/archive/main.zip.

Exécutez un kata en tant que cahier Jupyter

La meilleure façon d'exécuter les Katas en tant que cahiers Jupyter est de naviguer vers le dossier racine du référentiel et d'ouvrir index.ipynb à l'aide de Jupyter:

$ cd QuantumKatas/
$ jupyter notebook index.ipynb

Cela ouvrira le cahier qui contient une liste de tous les katas et tutoriels, et vous pourrez naviguer vers celui que vous souhaitez utiliser des liens.

Remarque: Cela démarrera Jupyter Notebooks Server dans la même fenêtre de ligne de commande que vous avez utilisée pour exécuter la commande. Si vous souhaitez continuer à utiliser cette fenêtre pour la navigation, vous pouvez lancer Jupyter Notebooks Server dans une nouvelle fenêtre en utilisant les commandes suivantes:

Pour Windows:

$ cd QuantumKatas/
$ start jupyter notebook index.ipynb

Pour Ubuntu:

$ cd QuantumKatas/
$ gnome-terminal -- start jupyter notebook index.ipynb

Vous pouvez également ouvrir directement un cahier individuel, mais cela peut rendre les liens internes invalides:

$ cd QuantumKatas/tutorials/ComplexArithmetic
$ jupyter notebook ComplexArithmetic.ipynb

Exécutez un Kata comme un projet Q #

Chaque Kata est dans son propre répertoire en tant que projet Q # autonome, solution et triplet Jupyter. Par exemple, la structure du répertoire BasicGates est:

QuantumKatas/
  BasicGates/
    README.md                  # Instructions specific to this kata.
    .vscode/                   # Metadata used by Visual Studio Code.
    BasicGates.sln             # Visual Studio solution file.
    BasicGates.csproj          # Project file used to build both classical and quantum code.

    BasicGates.ipynb           # Jupyter Notebook front-end for this kata.
    Workbook_BasicGates.ipynb  # Jupyter Notebook workbook for this kata.

    Tasks.qs                   # Q# source code that you will fill as you solve each task.
    Tests.qs                   # Q# tests that verify your solutions.
    ReferenceImplementation.qs # Q# source code containing solutions to the tasks.

Pour ouvrir les BasicGates Kata dans Visual Studio 2022, ouvrez le fichier de solution quantumkatas / basicgates / basicgates.sln .

Pour ouvrir le BasicGates Kata dans Visual Studio Code, ouvrez le dossier Quantumkatas / Basicgates / . Appuyez sur Ctrl + Shift + P (ou ⌘ + Shift + P sur macOS) pour ouvrir la palette de commande . Tapez le dossier ouvert sur Windows 10 ou Linux ou ouvrez sur macOS.

CONSEIL
Presque toutes les commandes disponibles dans Visual Studio Code sont dans la palette de commandes. Si vous êtes coincé, appuyez sur Ctrl + Shift + P (ou ⌘ + Shift + P sur macOS) et commencez à taper pour rechercher dans toutes les commandes disponibles.

Vous pouvez également lancer Visual Studio Code à partir de la ligne de commande:

$ code QuantumKatas/BasicGates/

Exécutez les tests Kata

Une fois que vous avez un kata ouvert, il est temps d'exécuter les tests en utilisant les instructions suivantes. Initialement, tous les tests échoueront. Ne pas paniquer! Ouvrez les tâches.qs et commencez à remplir le code pour terminer les tâches. Chaque tâche est couverte par un test unitaire. Une fois que vous avez rempli le code correct pour une tâche, reconstruisez le projet et réécoutez les tests, et le test unitaire correspondant passera.

Visual Studio 2022

1. Construire la solution.
2. Dans le menu principal, ouvrez l'explorateur de test ( test > Windows ) et sélectionnez Tous pour exécuter tous les tests unitaires à la fois.
3. Travaillez sur les tâches du fichier tasks.qs .
4. Pour tester vos modifications de code pour une tâche, reconstruisez la solution et réévaluez tous les tests unitaires à l'aide de l'exécution de tous , ou exécutez uniquement le test pour cette tâche en cliquant avec le bon clic et en sélectionnant Exécuter des tests sélectionnés .

Code Visual Studio

1. Appuyez sur Ctrl + ` (ou ⌘ +` sur macOS) pour ouvrir le terminal intégré. Le terminal doit s'ouvrir au répertoire KATA. Si ce n'est pas le cas, accédez au dossier contenant le fichier * .csproj pour la commande kata à l'aide cd .
2. Exécutez dotnet test dans le terminal intégré. Cela devrait construire le projet KATA et exécuter tous les tests unitaires. Tous les tests unitaires doivent échouer.
3. Travaillez sur les tâches du fichier tasks.qs .
4. Pour tester vos modifications de code pour une tâche, à partir du dotnet test .

Pour plus de commodité, un fichier de configuration tasks.json existe pour chaque kata. Il permet à Visual Studio Code d'exécuter les étapes de construction et de test de la palette de commandes. Appuyez sur Ctrl + Shift + P (ou ⌘ + Shift + P sur macOS) pour ouvrir la palette et taper la tâche de construction d'exécution ou exécuter la tâche de test et appuyer sur Entrée .

Exécutez Katas localement avec Docker

Vous pouvez utiliser le DockerFile inclus pour créer une image Docker avec tous les outils nécessaires pour exécuter les Katas à partir de la ligne de commande ou du jupyter.

1. Installer docker.
2. Construisez l'image docker et taguez-le katas :

docker build -t katas .

3. Exécutez l'image dans le conteneur nommé katas-container avec une ligne de commande interactive et un port de conteneur de redirection 8888 vers le port local 8888 (nécessaire pour exécuter Jupyter):

docker run -it --name katas-container -p 8888:8888 katas /bin/bash

4. À partir de la même ligne de commande que vous avez utilisée pour exécuter le conteneur, exécutez la version C # du BasicGates Kata:

 cd ~ /BasicGates/
dotnet test

5. Démarrez un cahier Jupyter dans l'image pour le BasicGates Kata:

 cd ~ /BasicGates/ && jupyter notebook --ip=0.0.0.0 --no-browser

6. Une fois que Jupyter a commencé, utilisez votre navigateur pour ouvrir le format Kata au format. Vous aurez besoin d'un jeton généré par Jupyter lorsqu'il a commencé à l'étape précédente:

 http://localhost:8888/notebooks/BasicGates.ipynb

Pour quitter un conteneur Docker sans le tuer (mode démon), appuyez sur Ctrl + P, Ctrl + Q

Pour réintégrer le katas-container existant (en mode démon):

docker attach katas-container

Une fois que vous avez terminé, supprimez le katas-container :

docker rm --force katas-container

Contributif

Ce projet accueille les contributions et les suggestions. Voyez comment puis-je contribuer? pour plus de détails.

Code de conduite

Ce projet a adopté le code de conduite open source Microsoft. Pour plus d'informations, consultez le code de conduite FAQ ou contactez [email protected] avec toute question ou commentaire supplémentaire.