Exécuter des circuits quantiques

Regarde la vidéo sur les circuits quantiques et les primitives d'Olivia Lanes, ou ouvre la vidéo dans une fenêtre séparée sur YouTube.

Aperçu de la leçon

Cette leçon donnera un aperçu général des bases de l'exécution d'un calcul quantique à l'échelle utilitaire, depuis le matériel quantique utilisé jusqu'aux principes à considérer lors de la conception d'un circuit quantique. Idéalement, à la fin de cette leçon, tu sauras :

1. Ce que sont réellement les ordinateurs quantiques IBM®. Tu devras connaître les bases des caractéristiques du matériel pour concevoir de manière optimale tes circuits quantiques à exécuter dessus.

2. Ce qu'est Qiskit, ce que sont les primitives, et comment nous pouvons les utiliser pour créer et exécuter des circuits quantiques.

3. Le flux de travail typique que nous suivons pour exécuter des expériences à grande échelle. Cela inclut la sélection des meilleures primitives pour ton cas d'usage, la correspondance d'un problème à un circuit quantique, et l'application de l'atténuation et de la suppression d'erreurs, qui nous permettent d'extraire le maximum de puissance de ces machines.

Matériel — processeurs quantiques IBM

Pour comprendre comment nous pouvons faire des choix optimaux dans la conception de circuits quantiques à grande échelle, nous devons en savoir un peu sur le matériel réel qui exécutera ces circuits. Discutons donc brièvement des qubits physiques et des processeurs quantiques IBM.

Les processeurs quantiques IBM sont construits à l'aide de qubits transmon supraconducteurs, qui sont des circuits électriques composés d'une jonction Josephson et d'un condensateur connectés en parallèle. La jonction Josephson est un inducteur non linéaire créé à partir de deux couches superposées de métal supraconducteur avec une barrière isolante entre elles. À très basses températures, les électrons dans les supraconducteurs se regroupent en paires pour former ce qu'on appelle une paire de Cooper. Les paires de Cooper peuvent spontanément traverser par effet tunnel la barrière isolante d'un côté de la jonction à l'autre. Ce comportement d'effet tunnel donne naissance aux propriétés non linéaires qui créent notre qubit.

Des lignes de transmission micro-ondes sont fabriquées sur la puce pour délivrer des signaux micro-ondes aux qubits. Lorsqu'on applique des impulsions micro-ondes hautement calibrées — avec des fréquences, amplitudes, formes et durées spécifiques — sur les lignes, on peut faire que les qubits effectuent des actions spécifiques. Cela constitue la base de nos portes quantiques. Nous fabriquons la puce de sorte que les qubits voisins soient connectés dans une structure de réseau spécifique appelée réseau heavy-hex. Cette connectivité — la topologie — de nos processeurs est un facteur important à considérer lors de la conception d'un circuit, comme nous le discuterons plus loin dans la leçon.

Les instructions pour l'impulsion micro-onde vont de ton ordinateur, par le cloud, et aux électroniques de contrôle à température ambiante, qui interprètent ces instructions et génèrent physiquement les impulsions. Après que les boîtiers de contrôle à température ambiante créent les impulsions, elles voyagent par des câbles dans un réfrigérateur à dilution et finalement vers la puce quantique. Le signal entre dans les résonateurs, traverse une connexion par fil de soudure, puis coule dans la ligne de transmission jusqu'à nos qubits.

IBM dispose de dizaines d'ordinateurs quantiques dans le monde, et nous avons récemment mis à niveau notre flotte pour avoir exclusivement des processeurs de plus de 100 qubits. Certains se trouvent dans un centre de données quantiques IBM dans le nord de l'État de New York et sont déployés sur le cloud pour l'usage de tous — et certains sont des systèmes dédiés, sur site, qui soutiennent les partenaires du réseau IBM Quantum®. Tu peux te connecter à quantum.cloud.ibm.com pour voir à quels processeurs tu as accès.

Chaque processeur répertorie trois métriques de performance, que nous avons discutées dans la leçon précédente, mais pour rappel, ce sont : le nombre de qubits, l'EPLG et les CLOPS.

• Nombre de qubits. C'est explicite : c'est le nombre total de qubits disponibles sur un processeur quantique unique. Pour un problème relativement large à l'échelle utilitaire, tu devras t'assurer d'utiliser un processeur avec suffisamment de qubits pour pouvoir s'attaquer au problème. Mais le nombre de qubits seul n'est pas la seule chose qui compte.

• EPLG, ou « erreurs par porte en couche ». C'est une mesure de la qualité des qubits et des portes quantiques. Elle mesure l'erreur moyenne que chaque porte introduit dans un circuit qui intrigue des qubits voisins dans une chaîne de 100 qubits. Tu veux que ce soit aussi petit que possible.

• CLOPS, ou « opérations de couches de circuits par seconde ». Cela quantifie la vitesse du processeur. Il mesure combien de couches d'un certain circuit de référence appelé circuit de volume quantique une unité de traitement quantique (QPU) peut exécuter par unité de temps. Plus le nombre est élevé, plus le calcul est rapide.

L'importance de chacune de ces métriques varie selon l'application spécifique, et dans les leçons futures, nous examinerons des exemples réels pour voir comment chacun de ces facteurs peut affecter le résultat d'un calcul.

Logiciels : Qiskit et Qiskit Runtime

Pour transformer ton problème quantique en instructions pour un ordinateur quantique, tu utiliseras Qiskit, le kit de développement logiciel open-source conçu pour travailler sur des ordinateurs quantiques développé par IBM. Il y a aussi l'écosystème Qiskit — une collection de tutoriels logiciels et de fonctions qui s'appuient sur ou étendent les fonctionnalités de base de Qiskit — et Qiskit Runtime — un service et modèle de programmation de calcul quantique qui permet aux utilisateurs de concevoir et d'optimiser leurs charges de travail quantiques et de les exécuter efficacement en utilisant les primitives Qiskit Runtime.

Une primitive est un petit bloc de construction que tu peux utiliser pour concevoir un circuit ou un emploi plus grand. Les deux primitives les plus importantes pour nous sont l'échantillonneur et l'estimateur, que nous discuterons plus en profondeur prochainement.

Avec la récente sortie de Qiskit v1.0, Qiskit est devenu plus performant et stable que jamais. Donc, pour ceux d'entre vous qui commencent tout juste, vous êtes arrivés au bon moment ! Pour ceux d'entre vous qui sont déjà familiers avec Qiskit, vous devrez télécharger et réinstaller la version la plus récente. Pour un guide d'installation complet, consultez le guide Installer Qiskit.

Circuits quantiques

Nous sommes maintenant prêts à discuter du fondement des programmes quantiques : les circuits quantiques. Cette section ne servira que de rappel — si tu n'es pas familier avec les circuits quantiques, nous recommandons d'en apprendre plus à leur sujet en visitant la leçon Circuits quantiques dans le cours « Bases de l'information quantique » avant de continuer.

Un circuit quantique est un réseau de portes quantiques et de mesures reliées par des fils représentant des qubits, comme illustré ci-dessous. Les circuits quantiques peuvent être lus comme des partitions musicales, de gauche à droite, en commençant au temps 0 à gauche. Les qubits virtuels — ceux qui n'ont pas encore été assignés à un qubit physique sur un processeur — sont listés en ordre croissant de haut en bas.

Les portes sont représentées par différents symboles sur les fils des qubits impliqués. Les portes à un seul qubit — comme une porte Hadamard, représentée ci-dessous (la boîte avec le H) — n'affectent que le qubit dont elle touche le fil. Les portes à plusieurs qubits — comme une porte CNOT, également représentée ci-dessous (le signe plus dans le cercle avec une ligne reliée à q0) — affectent deux qubits ou plus. Dans la porte CNOT représentée, l'état de q1 change selon l'état de q0. Après l'exécution de toutes les portes, on peut mesurer les qubits, indiqué par les portes noires avec le symbole de mesure. Les résultats des mesures sont écrits dans les registres classiques, le bus « meas » à double ligne ci-dessous.

Une caractéristique importante d'un circuit est sa profondeur. La profondeur d'un circuit quantique est le nombre minimum de « couches » de portes quantiques, exécutées en parallèle, nécessaires pour compléter le circuit. Les portes quantiques peuvent être exécutées en parallèle (en même temps) lorsqu'elles n'ont aucun qubit en commun. Mais si deux portes ou plus agissent sur le même qubit, on ne peut pas les exécuter en parallèle — elles doivent être effectuées en deux couches séparées, l'une après l'autre.

Il existe une autre façon moins évidente de déterminer la profondeur d'un circuit, en jouant à une sorte de jeu. Les règles sont simples : en partant de n'importe quel fil de qubit sur la gauche, tu dois voyager vers la droite et compter le nombre de portes que tu rencontres sur ton chemin. Tu peux sauter vers un fil voisin uniquement lorsqu'il est connecté à ton fil actuel par une porte à plusieurs qubits. Le but est de maximiser le nombre de portes que tu rencontres le long de ton chemin. Ce nombre maximal correspond également à la profondeur du circuit.

Parce que les portes quantiques prennent du temps à implémenter, la profondeur d'un circuit correspond approximativement à la quantité de temps nécessaire pour qu'un ordinateur quantique exécute le circuit. Certaines machines sont mieux adaptées aux circuits de grande profondeur que d'autres en raison des temps de décoherence des qubits sur le processeur. Nous devons donc connaître la profondeur d'un circuit pour savoir s'il peut être exécuté sur un appareil particulier.

Conception d'un circuit quantique : les motifs Qiskit

Alors, comment procède-t-on pour concevoir et exécuter un circuit quantique ? La façon la plus facile de comprendre un flux de travail typique de calcul quantique est à travers les motifs Qiskit. Les motifs Qiskit sont un cadre conceptuel permettant aux utilisateurs d'exécuter des charges de travail quantiques en implémentant certaines étapes avec des outils modulaires. Cela permet aux tâches de calcul quantique d'être effectuées par une infrastructure informatique hétérogène puissante (CPU/GPU/QPU). Les étapes peuvent être effectuées en tant que service et peuvent incorporer la gestion des ressources, ce qui permet la composabilité transparente de nouvelles capacités au fur et à mesure de leur développement.

Voici les principales étapes, que les utilisateurs expérimentés de Qiskit reconnaîtront probablement.

1. Correspondance. Cette étape formalise la façon dont on prend un problème général qui nous intéresse et comment le mapper sur un ordinateur quantique sous la forme d'un circuit quantique.

2. Optimisation. Dans cette étape, on utilise le transpilateur de Qiskit pour router et disposer le circuit sur un matériel quantique physique réel. Cela inclut la traduction des portes quantiques individuelles en séquences d'opérations effectuées sur le matériel ainsi qu'une optimisation dans la disposition des portes.

3. Exécution. Les primitives Qiskit Runtime fournissent l'interface avec le matériel IBM Quantum qui permet aux circuits transpilés de s'exécuter. Cette étape inclut également l'utilisation de techniques de suppression et d'atténuation d'erreurs, qui peuvent être largement abstraites de l'utilisateur.

4. Post-traitement. Dans cette étape, les données du processeur quantique lui-même sont traitées, fournissant à l'utilisateur des résultats utiles sur le problème original. En gros, cela englobe toute analyse supplémentaire des données acquises.

Correspondance

L'étape de correspondance pose essentiellement la question : « Comment je traduis mon problème en circuit quantique qui peut raisonnablement être exécuté sur du matériel quantique ? » C'est indéniable : la correspondance est un problème difficile et un domaine de recherche actif. Il n'existe pas de méthode infaillible qui garantit le succès, mais il y a des lignes directrices recommandées et des exemples de problèmes qu'on sait déjà comment mapper.

La première directive est de laisser les ordinateurs classiques faire tout le travail pour lequel ils sont meilleurs. Les tâches faciles pour les ordinateurs classiques ne bénéficieront probablement pas d'un ordinateur quantique. Les ordinateurs quantiques sont pour les problèmes classiquement difficiles. Bien sûr, si c'est ta toute première fois que tu utilises Qiskit ou un ordinateur quantique, ne t'inquiète pas de trouver un problème computationnellement complexe. Décompose-le en problèmes plus petits et faciles à gérer que tu peux apprendre à résoudre avant de te lancer directement dans un projet à l'échelle utilitaire.

Ensuite, traduis les résultats de ton problème que tu souhaites mesurer ou comprendre en une valeur d'espérance ou une fonction de coût. Une fonction de coût est une fonction spécifique au problème qui définit l'objectif du problème comme quelque chose à minimiser ou maximiser. Elle peut être utilisée pour voir à quel point un état ou une solution d'essai se comporte par rapport à cet objectif. Cette notion peut être appliquée à diverses applications en chimie, apprentissage automatique, finance, optimisation, etc. — la discipline d'où tu abordes le problème n'a pas forcément d'importance.

Garde également à l'esprit que le matériel que tu vas utiliser a une topologie spécifique, comme nous l'avons discuté dans la section matériel. Certains qubits sont connectés, et d'autres non — tu devras mapper ton problème à un circuit qui respecte la topologie heavy-hex des processeurs quantiques IBM.

Pour l'instant, la chose la plus importante à garder à l'esprit est que cette étape nécessite de la pratique. Tu dois avoir une bonne compréhension non seulement de ton problème, mais aussi des capacités du matériel — et nous examinerons des exemples spécifiques et des cas d'usage dans les leçons futures pour voir comment équilibrer toutes ces considérations.

Optimisation

Ensuite, nous devrons choisir un processeur quantique qui a suffisamment de qubits de qualité suffisamment élevée pour que nous puissions exécuter notre circuit quantique. Prends ces décisions guidé par les trois métriques dont nous avons discuté dans la section matériel : le nombre de qubits, l'EPLG et les CLOPS.

Nous optimisons ensuite notre circuit pour le matériel sélectionné. Premièrement, nous devons disposer et router efficacement notre circuit. La disposition fait référence à la correspondance des qubits virtuels dans le circuit aux qubits physiques sur le processeur. Le routage fait référence à la modification du circuit pour que la connectivité entre les qubits virtuels dans le circuit corresponde à la connectivité des qubits physiques sur le processeur. Il y a quelques points à garder à l'esprit lors de l'étape de disposition et de routage.

1. Tous les qubits ne sont pas connectés. Certains sont très éloignés les uns des autres sur la puce, et nous devons réduire ou éliminer les interactions longue distance dans la mesure du possible. Tu pourrais appliquer une séquence de portes SWAP entre les qubits voisins pour déplacer les informations des qubits, mais les portes SWAP sont coûteuses et sujettes aux erreurs, donc il peut y avoir de meilleures façons de faire cela. Essaie d'éviter trop de portes SWAP coûteuses.

2. La disposition et le routage sont des processus itératifs. Tu peux le faire à la main, mais il existe aussi un outil Qiskit appelé mapomatic, qui peut faire des recommandations pour une disposition de qubits physiques basée sur des taux d'erreur approximatifs. Le transpilateur (dont nous discuterons prochainement) peut également faire une suggestion informée.

Ensuite, on peut composer des séquences de portes à un qubit agissant sur le même qubit en portes uniques — et on peut parfois aussi se débarrasser de portes inutiles ou de combinaisons de portes. Par exemple, certaines combinaisons de portes peuvent être réduites à des combinaisons plus simples — et en fait, parfois une combinaison de portes peut équivaloir à l'opération identité, donc on peut simplement les éliminer. Tu peux le faire automatiquement en utilisant le transpilateur Qiskit — mais tu peux aussi le faire manuellement porte par porte si tu veux plus de contrôle.

Une fois que nous avons amélioré la disposition, le routage et le nombre de portes du circuit — que ce soit à la main ou en utilisant le transpilateur — nous voulons généralement visualiser notre circuit pour nous assurer que le timing de toutes les portes a du sens. Il y a un argument que tu peux signaler dans le transpilateur pour visualiser la chronologie de ton circuit, et t'assurer que tout est aligné comme tu le souhaites.

Transpilateur Qiskit

Comme mentionné précédemment, le Transpilateur Qiskit peut être utilisé pour aider dans les premières étapes du flux de travail des motifs. Maintenant, examinons ses capacités plus en détail. Il peut réécrire un circuit d'entrée donné pour qu'il corresponde à la topologie d'un appareil quantique spécifique et optimiser le circuit pour l'exécution et la résistance au bruit. Il réécrit également un circuit donné en portes de base du processeur quantique spécifique que tu as sélectionné.

Qiskit a quatre pipelines de transpilation intégrés correspondant à différents niveaux d'optimisation, et à moins d'être déjà familier avec l'optimisation de circuits quantiques, nous recommandons d'en utiliser un. Par défaut, le processus de transpilation comprend ces six étapes :

1. Initialisation. Cette étape exécute tous les passages initiaux requis avant de commencer à intégrer le circuit dans le backend. Cela implique généralement le dépliage des instructions personnalisées et la conversion du circuit en portes simples et à deux qubits uniquement.

2. Disposition. Cette étape mappe les qubits virtuels dans le circuit aux qubits physiques sur un backend. Voir Étape de disposition pour plus de détails.

3. Routage. Cette étape s'exécute après l'application d'une disposition et injecte des portes (telles que des portes de permutation) dans le circuit original pour le rendre compatible avec la connectivité du backend. Voir Étape de routage pour plus de détails.

4. Traduction. Cette étape traduit les portes du circuit vers l'ensemble de bases du backend cible. Voir Étape de traduction pour plus de détails.

5. Optimisation. Cette étape exécute la boucle d'optimisation principale de manière répétée jusqu'à ce qu'une condition (comme l'atteinte d'une certaine profondeur cible) soit remplie. Nous avons quatre niveaux d'optimisation différents parmi lesquels choisir, décrits ci-dessous.

6. Ordonnancement. Cette étape est pour tout passage d'ordonnancement tenant compte du matériel. À un niveau élevé, l'ordonnancement peut être considéré comme l'insertion de délais dans le circuit pour tenir compte du temps d'inactivité des qubits entre l'exécution des instructions.

Il existe quatre niveaux d'optimisation allant de 0 à 3, où des niveaux d'optimisation plus élevés prennent plus de temps et d'efforts computationnels mais peuvent produire un meilleur circuit. Le niveau d'optimisation 0 est destiné aux expériences de caractérisation d'appareils et, en tant que tel, mappe uniquement le circuit d'entrée aux contraintes du backend cible, sans effectuer d'optimisations. Le niveau d'optimisation 3 consacre le plus d'efforts à l'optimisation du circuit. Cependant, comme de nombreuses techniques d'optimisation dans le transpilateur sont basées sur des heuristiques, consacrer plus d'efforts computationnels ne résulte pas toujours en une amélioration de la qualité du circuit de sortie. Si cela t'intéresse davantage, consulte la documentation du transpilateur dans la documentation Qiskit.

Suppression d'erreurs

La première étape pour réduire les erreurs dans un circuit est l'optimisation de la disposition, du routage et la minimisation du nombre de portes, ce que nous avons déjà fait, que ce soit en utilisant le transpilateur ou par nous-mêmes. Parlons maintenant de méthodes plus sophistiquées de suppression d'erreurs.

La suppression d'erreurs désigne une classe de techniques qui transforment un circuit lors de la compilation pour minimiser les erreurs. Elle est distincte de l'atténuation d'erreurs, dont nous discuterons plus tard dans la section « Exécution » ci-dessous. Les deux formes les plus courantes de suppression d'erreurs que nous utilisons sont le découplage dynamique et le tourbillonnement de Pauli :

1. Le découplage dynamique est utilisé pour annuler efficacement une partie du bruit environnemental introduit lorsqu'un qubit est inactif. En appliquant une série de portes à des moments spécifiques, on peut faire en sorte que le bruit qui s'accumule dans une partie de la période d'inactivité annule approximativement le bruit dans l'autre partie.
2. Le tourbillonnement de Pauli est une façon d'insérer des portes aléatoires non pas pour annuler le bruit, comme dans le découplage dynamique, mais pour le simplifier. En insérant des portes aléatoires, cela empêche les effets de différentes erreurs de s'accumuler aussi rapidement, et rend le bruit plus facile à caractériser, car il a maintenant une nature stochastique. Cette méthode forme également la base d'une puissante technique d'atténuation d'erreurs, que nous discuterons ci-dessous.

Exécution

Nous sommes maintenant prêts à exécuter le programme quantique. Les primitives Qiskit Runtime fournissent une interface avec le matériel IBM Quantum, et elles abstraient également la suppression et l'atténuation d'erreurs de l'utilisateur. Il y a deux primitives parmi lesquelles choisir : l'Échantillonneur et l'Estimateur.

L'Échantillonneur de Qiskit Runtime exécute le circuit plusieurs fois sur un appareil quantique, effectuant des mesures à chaque exécution, et reconstruisant la distribution de probabilité à partir des chaînes de bits récupérées. Plus il effectue d'exécutions (ou coups), plus les résultats seront précis, mais cela nécessite plus de temps et de ressources quantiques. En particulier, il calcule la probabilité d'obtenir chaque état de base standard possible en mesurant l'état préparé par le circuit.

L'Estimateur de Qiskit Runtime utilise un processus algébrique complexe pour estimer la valeur d'espérance sur un appareil quantique réel en décomposant l'observable en une combinaison d'autres observables avec des bases propres connues.

L'étape d'exécution est également le moment où nous pouvons sélectionner la stratégie d'atténuation d'erreurs. L'atténuation d'erreurs désigne des techniques qui permettent aux utilisateurs de réduire les erreurs de circuit en modélisant le bruit de l'appareil qui était présent au moment de l'exécution. Typiquement, cela entraîne une surcharge de pré-traitement quantique liée à l'entraînement du modèle et une surcharge de post-traitement classique pour atténuer les erreurs dans les résultats bruts en utilisant le modèle généré. En échange de cette surcharge, nous sommes capables d'obtenir des résultats beaucoup plus précis.

Il existe plusieurs techniques que nous pouvons implémenter pour l'atténuation d'erreurs. Nous en discuterons trois, dans l'ordre croissant de résistance aux erreurs, mais aussi, par conséquent, dans l'ordre croissant du coût computationnel. Sois conscient, cependant, que c'est un domaine de recherche actif — donc nous continuerons probablement à en inventer de nouvelles et à améliorer les anciennes.

Au niveau de résilience 0, le transpilateur ne fait rien à ton circuit.

Au niveau 1, il introduit une méthode appelée Twirled Readout Error eXtinction (T-REX). T-REX utilise le tourbillonnement de Pauli, comme discuté dans la section de suppression d'erreurs. Comme mentionné, insérer des portes aléatoires dans le circuit peut faire en sorte que même un bruit très compliqué et difficile à modéliser paraisse stochastique, et beaucoup plus facile à prendre en compte ou à soustraire dans le post-traitement.

Au niveau de résilience 2, l'Extrapolation à Bruit Zéro (ZNE) est ajoutée. C'est une technique populaire avec laquelle nous avons eu beaucoup de succès récemment. L'idée derrière ZNE peut être un peu surprenante — nous ajoutons réellement du bruit par-dessus ce qui est déjà là ! Mais cela nous permet d'extrapoler dans la direction inverse, pour prédire à quoi ressembleraient les résultats s'il y avait de moins en moins de bruit.

L'ajout de bruit peut être accompli de quelques façons différentes. Par exemple, on peut étirer les portes pour les rendre plus longues et donc plus sujettes aux erreurs, ou exécuter plus de portes qui donnent finalement une opération identité, donc le circuit ne change pas fonctionnellement mais on échantillonne intentionnellement plus de bruit. Tu dois cependant faire cela pour chaque circuit et chaque valeur d'espérance que tu veux suivre — donc tu peux voir comment cela peut finir par être computationnellement coûteux.

Un type spécifique de ZNE s'appelle l'Amplification d'Erreurs Probabiliste (PEA). Une fois que nous avons appris un modèle de bruit pour une porte, PEA fonctionne en échantillonnant des erreurs à partir de ce modèle de bruit et en les injectant délibérément dans le circuit. Ce n'est pas encore disponible dans Qiskit, mais ce le sera plus tard cette année.

La dernière forme d'atténuation d'erreurs dont nous discuterons est l'Annulation d'Erreurs Probabiliste (PEC). Au lieu d'être au 3ème niveau de résilience, PEC est une capacité spéciale que tu dois activer manuellement dans Qiskit, car les ressources computationnelles requises ne se dimensionnent pas très bien par rapport aux autres techniques d'atténuation d'erreurs. Tu commences par apprendre le bruit qui affecte ton circuit — exécute des circuits d'apprentissage du bruit ou de caractérisation du bruit pour chaque couche unique de portes à deux qubits dans ton circuit. Ces résultats te permettent de décrire le bruit en termes d'opérateurs de Pauli. Une fois que tu connais ces termes de bruit, tu peux modifier tes circuits pour qu'ils aient effectivement les portes de Pauli opposées intégrées pour annuler ces canaux de bruit. À certains égards, le processus est similaire au fonctionnement des casques anti-bruit. Cependant, cette façon d'annuler le bruit est très coûteuse, avec un temps d'exécution qui croît rapidement et exponentiellement avec le nombre de portes, donc ce n'est peut-être pas le meilleur choix pour un très grand circuit.

Post-traitement

L'étape de post-traitement est l'endroit où nous visualisons et analysons la sortie de notre circuit quantique. Il existe un certain nombre d'outils Qiskit disponibles pour le faire, comme les modules de visualisation et quantum-info. Nous ne les couvrirons pas ici, mais nous verrons ces modules en action lorsque nous plongerons dans des exemples d'applications dans les leçons futures.

Conclusion

Espérons que cette leçon t'a donné une visite éclair des principales considérations et du flux de travail que nous utilisons lorsque nous voulons exécuter un calcul quantique à l'échelle utilitaire. Elle était riche en informations, et une grande partie ne s'assimilera pas avant de voir des exemples concrets où ces concepts théoriques sont mis en pratique. C'est donc ce que sera le reste du cours. Après tout, ce cours ne s'appelle pas « Le calcul quantique en pratique » pour rien !

La prochaine fois, nous examinerons un exemple spécifique de la façon d'utiliser le flux de travail des motifs Qiskit pour concevoir et exécuter un circuit quantique qui résout le problème classique de théorie des graphes appelé MaxCut.