Bruit et erreurs

Cette leçon présentera le bruit et les erreurs quantiques, y compris nombre de leurs sources, en établissant des analogies avec les erreurs classiques. Comprendre les types d'erreurs pouvant survenir, ainsi que la capacité à modéliser le bruit à l'aide de canaux quantiques, seront essentiels pour comprendre les leçons futures. En effet, la plupart des méthodes de gestion des erreurs exigent que nous sachions quelque chose sur le type de bruit ou d'erreurs que nous cherchons à réduire ou à corriger.

Cette vidéo donne un aperçu du bruit et des erreurs, et met en avant quelques résultats de calcul. Le texte ci-dessous apporte plus de détails et explore certains types d'erreurs à l'aide de Qiskit.

Causes

Bruit et erreurs classiques

Pour comprendre les erreurs et le bruit quantiques, commençons par l'analogue classique. Des erreurs surviennent dans les ordinateurs classiques pour diverses raisons, notamment plusieurs mécanismes d'accumulation de charge parasite, des événements singuliers (single-event upsets) et une lente dégradation des matériaux. Certains de ces mécanismes (pas tous) ont des analogues en informatique quantique et seront essentiels pour comprendre les erreurs et le bruit quantiques. Nous passons brièvement en revue quelques-uns d'entre eux avant de passer aux analogues quantiques.

Bruit thermique :

À mesure que les composants d'un ordinateur chauffent, le mouvement thermique des atomes et des porteurs de charge modifie la résistivité du matériau (généralement en l'augmentant). Cela signifie que la résistance du circuit peut varier. Bien que rare, cela peut entraîner une transition logique parasite dans un transistor. Bien que de légères variations soient inévitables, un refroidissement adéquat des composants est essentiel pour éviter ces effets.

Dommages thermiques et dégradation :

Le chauffage et le refroidissement répétés des matériaux peuvent provoquer une migration très lente des éléments conducteurs (métaux). Au mieux, cela modifie la résistance ou la capacité (ou les deux) des éléments du circuit et entraîne une imprécision du timing dans le fonctionnement du circuit. Au pire, cela entraîne un court-circuit ou une panne matérielle. Là encore, un contrôle adéquat de la température est essentiel pour prévenir ce type de dégradation.

Effets induits par les radiations (single-event upsets, SEU) :

Parfois, des particules à haute énergie peuvent ioniser des atomes à l'intérieur d'un processeur et provoquer une charge parasite. Si cela se produit au mauvais endroit et au mauvais moment, cela peut entraîner des erreurs logiques. La source de ces particules à haute énergie (y compris le rayonnement électromagnétique et les neutrons) provient généralement d'interactions à haute énergie dans la haute atmosphère. Ces perturbations sont donc plus fréquentes dans les environnements en haute altitude, y compris dans l'espace. Elles sont traitées à l'aide de codes correcteurs d'erreurs et d'une conception durcie aux radiations.

Interférences électromagnétiques :

Des erreurs peuvent également être causées par des champs électromagnétiques (EM) externes provenant de lignes d'alimentation commutées, d'émetteurs radio ou d'autres composants du système. Ceci est différent du rayonnement à haute énergie du phénomène précédent. Ici, des champs EM parasites variant dans le temps induisent du courant et de la tension à travers les composants informatiques (par opposition à l'ionisation d'un atome particulier lors d'un seul événement). Comme la dépendance temporelle des champs est un facteur déterminant dans les tensions induites, ce type d'interférence est particulièrement important dans les systèmes à haute fréquence. Ces erreurs peuvent être combattues par le blindage et la mise à la terre, entre autres.

Diaphonie entre interconnexions :

Le couplage capacitif ou inductif entre conducteurs adjacents, en particulier dans les circuits intégrés à l'échelle nanométrique, peut entraîner des signaux parasites. Cela est lié aux interférences électromagnétiques, mais c'est différent car la source du champ incriminé est un autre composant à l'intérieur du circuit informatique. Imagine deux fils très proches l'un de l'autre. Si le fil A subit une transition soudaine (changement de tension), cela peut induire des courants dans le fil adjacent B. La direction et l'amplitude exactes dépendent de la disposition du circuit ; il peut s'agir d'un flux net cohérent de charge ou de quelque chose de plus proche de courants de Foucault de charge. Mais dans certains cas, cela peut entraîner des transitions logiques indésirables. Ces effets de diaphonie peuvent être atténués par un espacement optimal de la disposition, un blindage et des temps de montée de signal contrôlés.

Ce n'est pas une liste exhaustive, mais elle est suffisante pour commencer à voir des parallèles avec l'informatique quantique. Note que dans tous les types d'interactions indésirables ci-dessus, la manifestation du bruit sous forme d'erreur logique ne peut prendre que la forme d'un 0 devenant un 1, ou d'un 1 devenant un 0. C'est tout ce qui est permis dans l'espace d'états des bits classiques.

Bruit et erreurs quantiques

En informatique quantique, le bruit et les erreurs sont souvent évoqués ensemble, mais il est important de reconnaître la différence. Le bruit quantique désigne la perturbation physique sous-jacente affectant les qubits et les systèmes quantiques. Il comprend toutes les formes d'interactions ou de fluctuations indésirables provenant de l'environnement, de contrôles imparfaits ou de défauts matériels qui font dériver l'état quantique par rapport à l'idéal. Les erreurs quantiques sont les déviations ou défauts spécifiques de l'information quantique résultant du bruit quantique. Les erreurs quantiques sont les manifestations mesurables ou opérationnelles du bruit, et les erreurs comprennent les bit-flips, les phase-flips, l'amortissement d'amplitude, et plus encore. Le bruit et les erreurs peuvent tous deux survenir de manière continue. Par exemple, le champ utilisé dans une porte quantique pourrait être décalé de 0,1 %, 0,15 % ou toute autre fraction. Cela pourrait entraîner une phase incorrecte sur un qubit, également selon une quantité continue quelconque. Mais tu verras que, en pratique et en particulier dans la correction d'erreurs, il est courant de voir les erreurs traitées comme si elles étaient discrètes : en regroupant les effets accumulés en un bit-flip discret ou une seule rotation de phase. Cela est utile pour corriger les erreurs et les caractériser, mais cela ne signifie pas que l'effet du bruit sur un qubit se limite à un ensemble discret d'erreurs.

Il existe de nombreux types de bruit affectant les ordinateurs quantiques. Certains peuvent entraîner plusieurs types d'erreurs, tandis que d'autres sont associés à des manifestations d'erreur spécifiques. Une liste exhaustive dépasse le cadre de cette leçon ; voici une liste partielle pertinente pour la suite de ce cours, certains éléments ayant des parallèles avec le bruit en informatique classique.

Thermal:

Les deux états de base computationnels $|0\rangle$ et $|1\rangle$ d'un qubit sont séparés par une très faible quantité d'énergie. La valeur exacte dépend, bien sûr, du matériel quantique. Pour les qubits à l'état solide (transmon à fréquence fixe) tels que ceux utilisés par IBM Quantum®, l'écart d'énergie entre ces états est de l'ordre de $10^{-24}$ J, soit quelques microélectronvolts. Cette échelle d'énergie peut être reliée à la fréquence via $E=hf$ ou à une température caractéristique. Comme la température est liée à l'énergie cinétique moyenne des particules dans un échantillon, nous pouvons utiliser la constante de Boltzmann pour obtenir une estimation de la température à laquelle des particules moyennes auraient suffisamment d'énergie pour provoquer une transition :

$$E\approx k_BT \rightarrow T~E/k_B \approx 10^{-24}\text{ J } \times 1.381 \times 10^{−23}\text{ J/K}\approx 100 \text{mK}.$$

Afin de réduire la probabilité que des interactions thermiques provoquent des transitions d'un état de base computationnel du qubit à un autre, la température des qubits doit être maintenue nettement en dessous de 100 mK, idéalement plus proche de 15-25 mK. Toute augmentation significative de la température au-delà de ces seuils entraînerait une occupation totalement aléatoire des états et une perte totale de l'information quantique.

Ceci est analogue aux erreurs thermiques pouvant survenir dans les ordinateurs classiques, en ce sens qu'elles sont toutes deux d'origine thermique — mais l'échelle de température est évidemment différente, tout comme le mécanisme de perte d'information.

Diaphonie et interférences :

La diaphonie en informatique quantique désigne tout couplage ou interférence indésirable entre qubits ou lignes de contrôle, de sorte qu'une opération ou un signal destiné à un qubit affecte par inadvertance d'autres qubits. Elle se manifeste par des erreurs ou des corrélations entre des qubits qui devraient idéalement être indépendants.

Dans les architectures de qubits supraconducteurs comme celles utilisées par IBM®, la diaphonie peut provenir de signaux de contrôle micro-ondes se propageant vers des qubits voisins, d'un couplage non intentionnel entre résonateurs de lecture, ou d'une diaphonie de flux entre boucles de qubits.

Bon nombre des approches visant à minimiser la diaphonie sont intégrées à la conception d'un ordinateur quantique, telles que l'espacement des qubits et le fait de veiller à ce que les qubits adjacents aient des fréquences de fonctionnement différentes. Il existe également des approches logicielles pour atténuer les erreurs de diaphonie, qui seront abordées dans les leçons ultérieures.

Opérations de porte imparfaites :

Les opérations sur les qubits sont réalisées à l'aide de matériel ayant une précision finie et pouvant être soumis au bruit ou à d'autres sources d'imprécision. En particulier, des impulsions micro-ondes de durées et d'orientations spécifiques sont utilisées pour mettre en œuvre des portes de rotation. Supposons par exemple qu'une impulsion micro-ondes doive effectuer une rotation de 0,30 radian autour de l'axe $X$. Il existe une précision finie dans l'orientation, entraînant une certaine imprécision dans l'axe de rotation. De plus, il existe toujours un compromis fondamental entre la fréquence d'une impulsion et sa durée. Une impulsion très longue peut avoir un comportement essentiellement sinusoïdal, avec pratiquement une seule fréquence. Pour former un paquet court, il faut une superposition de nombreuses fréquences. Il s'agit du même compromis qui est à la racine de la relation d'incertitude énergie-temps, bien que la précision des portes ne repousse pas encore ces limites fondamentales ; il reste une marge d'amélioration.

Bruit inhérent au quantique :

Ce dernier type de bruit est assez différent des autres ; il ne provient pas d'erreurs, mais de la nature de la mécanique quantique. Supposons qu'un qubit dans l'état quantique $|\psi\rangle$ soit mesuré et s'effondre vers un état propre ($|0\rangle$ ou $|1\rangle$). Dans un système transmon à fréquence fixe, le qubit est couplé de manière dispersive à un résonateur micro-ondes dont la fréquence de résonance dépend légèrement de l'état du qubit. Une impulsion de sondage micro-ondes est envoyée à travers le résonateur, et le signal sortant acquiert un déphasage et un changement d'amplitude dépendants de l'état. Ce signal est ensuite amplifié et mesuré à l'aide d'électronique classique.

Au niveau quantique, le signal de mesure est porté par un champ micro-ondes cohérent comportant un nombre moyen fini de photons. En raison de la nature quantique des champs électromagnétiques, les quadratures du champ présentent des fluctuations intrinsèques. Ces fluctuations sont indépendantes des imperfections techniques et apparaissent même pour un état cohérent idéal. L'augmentation du nombre moyen de photons $N$ augmente le signal de mesure, mais le niveau de bruit fondamental reste fini, de sorte que la distinguabilité entre les résultats ne s'améliore qu'en $\sqrt{N}$​.

Ainsi, même si le qubit est parfaitement préparé et que la chaîne de mesure est idéale, le signal de lecture correspondant à un état de qubit donné n'est pas une valeur unique fixe, mais une distribution qui limite la capacité à distinguer les résultats. Ce chevauchement représente une source fondamentale d'incertitude dans le processus de mesure lui-même. En pratique, bien que le bruit technique provenant des amplificateurs et d'autres composants domine souvent, ce bruit quantique intrinsèque fixe une limite inférieure à la fidélité de lecture.

L'incertitude n'est pas une erreur :

Ces sources de bruit sont toutes différentes de l'incertitude fondamentale associée aux mesures des états quantiques. À titre de comparaison, supposons que nous ayons un qubit dans un état quantique :

$|\psi\rangle = \frac{4}{5}|0\rangle+\frac{3}{5}|1\rangle.$

Cet état a 64 % de chances d'être mesuré dans l'état $|0\rangle$ et 36 % de chances d'être mesuré dans l'état $|1\rangle$. Mais une seule mesure ne donnera qu'un $|0\rangle$ ou un $|1\rangle$ — une seule mesure nous en apprendra donc rarement beaucoup sur l'état avant la mesure. De nombreuses mesures sont nécessaires pour obtenir des informations détaillées sur l'état. Sur dix mesures, on pourrait s'attendre à ce que six ou sept donnent $|0\rangle$. Mais il ne serait pas choquant que les dix premières mesures donnent toutes $|0\rangle$ (comme lancer une pièce équilibrée et obtenir « pile » dix fois de suite : peu fréquent, mais tout à fait plausible). Si nous répétions la mesure 1000 fois et obtenions toujours $|0\rangle$, cela serait effectivement choquant.

Il existe donc une incertitude dans notre connaissance de l'état quantique, quel que soit le nombre fini de mesures effectuées. Au fur et à mesure que nous répétons les mesures, notre connaissance de l'état quantique avant la mesure s'améliore, mais elle n'est jamais parfaite. On pourrait dire familièrement qu'il existe toujours une « erreur » sous-jacente dans tout résultat de mesure quantique. Mais il s'agit là d'un usage différent du terme « erreur », qu'il est préférable de décrire comme une incertitude statistique. Le processus consistant à accroître la connaissance d'un état quantique grâce à de nombreuses mesures s'appelle la tomographie d'état quantique. La tomographie d'état quantique ne se limite toutefois pas aux mesures selon Z ; elle désigne généralement des mesures selon des axes orthogonaux (comme X, Y et Z) pour la détermination des amplitudes et de la phase relative. Pour en savoir plus sur ce processus, consulte cette section du cours de John Watrous sur la Formulation générale de l'information quantique, ou pour une mise en œuvre pratique, consulte cette leçon sur la téléportation du cours sur l'informatique quantique à l'échelle utile.

Observer les erreurs et leur accumulation

Dans cette section, nous utiliserons de véritables ordinateurs quantiques pour observer les erreurs quantiques et leur accumulation dans différentes conditions. En pratique, de nombreuses sources d'erreurs quantiques sont généralement présentes simultanément. Afin d'observer différents types d'erreurs de manière relativement isolée, nous devrons utiliser des circuits conçus pour cette isolation. Les circuits utilisés dans les applications de l'informatique quantique paraîtront bien plus compliqués.

Commençons par les erreurs de relaxation énergétique.

Erreurs de relaxation énergétique ($T_1$)

Rappelle-toi, d'après notre discussion sur le bruit thermique, qu'à toute température non nulle, il existe une certaine probabilité qu'un système quantique subisse une transition entre états propres d'énergie. La relaxation ($|1\rangle \rightarrow |0\rangle$) domine car elle est pilotée par l'émission spontanée (indépendante de la température), tandis qu'une basse température supprime le processus d'excitation concurrent. Plus un qubit reste inactif longtemps, plus il a de temps pour subir une telle transition. La probabilité qu'un qubit préparé dans l'état $|1\rangle$ reste dans l'état $|1\rangle$ après un temps $t$ est donnée par

$$p = e^{-t/T_1}$$

Ici, le temps $T_1$ est un temps caractéristique déterminé expérimentalement, différent pour chaque qubit, et pouvant même varier légèrement au fil du temps. Les ordinateurs quantiques IBM® sont étalonnés régulièrement, de sorte que les temps $T_1$ répertoriés pour les qubits des ordinateurs quantiques IBM devraient être précis et à jour. Une valeur élevée de $T_1$ signifie que le qubit reste plus longtemps (en moyenne) dans l'état préparé. Les valeurs typiques de $T_1$ diffèrent selon les architectures ; les qubits des ordinateurs quantiques IBM ont souvent des temps $T_1$ de l'ordre de 200-300 $\mu s$, et tu peux vérifier les dernières valeurs sur la page des ressources de calcul.

Le temps caractéristique $T_2$ mesure quelque chose de différent : la perte d'information de phase. Nous y reviendrons plus tard.

Pour observer les erreurs de relaxation énergétique, nous allons préparer des qubits dans l'état $|1\rangle$, puis les laisser intentionnellement inactifs pendant de longues périodes. C'est la partie artificielle. Dans des flux de travail quantiques réels, tu pourrais avoir quelques qubits qui restent inactifs pendant de longues périodes pendant que des processus sont exécutés sur d'autres qubits ; par conséquent, quelques instances de telles périodes d'inactivité ne sont pas artificielles.

Commençons par importer quelques packages et sélectionner le backend le moins occupé.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"cycler": "cycler", "matplotlib": "matplotlib", "numpy": "numpy", "qiskit": "qiskit", "qiskit_aer": "qiskit-aer", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit_ibm_runtime import QiskitRuntimeService
import numpy as np
import matplotlib.pyplot as plt

# If your credentials are already saved locally
service = QiskitRuntimeService()

# To load an unsaved instance, uncomment the line below
# service = QiskitRuntimeService(channel = "ibm_quantum_platform", instance = "your crn here")

# To select the least-busy backend:
# backend = service.least_busy(simulator=False, operational=True)

# To specify the backend by name:
backend = service.backend("ibm_boston")

props = backend.properties()
print(backend)

<IBMBackend('ibm_boston')>

Nous allons maintenant sélectionner un qubit sur lequel travailler, dans ce cas, le qubit zéro. Nous pouvons importer directement les propriétés de ce qubit, y compris $T_1$ et $T_2$.

qubit_idx = 0
qubit_props = props.qubit_property(qubit_idx)

t1 = qubit_props["T1"][0]  # * 1e6  # Convert seconds to µs
t2 = qubit_props["T2"][0]  # * 1e6  # Convert seconds to µs

# print(f"Qubit {qubit_idx}: T1={t1} µs, T2={t2} µs")
print(f"Qubit {qubit_idx}: T1={t1} s, T2={t2} s")

Qubit 0: T1=0.0002737016180018049 s, T2=0.00042784777605680494 s

Connaître $T_1$ en microsecondes est important, mais tu n'as peut-être pas une idée intuitive de ce que cela signifie. Après tout, les opérations de porte sur les ordinateurs quantiques sont très rapides. La vraie question est : combien peut-on faire sur un ordinateur quantique dans ce laps de temps. À cette fin, il est utile de relier $T_1$ à d'autres échelles de temps utilisées en informatique quantique — en particulier aux suivantes :

• temps d'échantillonnage $dt$ - le plus petit tic d'horloge selon lequel les processus de contrôle peuvent être mis en œuvre sur l'ordinateur quantique.

• temps des portes à un qubit - le temps nécessaire pour mettre en œuvre une opération de porte sur un seul qubit. Il ne s'agira pas d'une valeur unique, mais d'une plage de valeurs possibles selon le type de porte.

• temps des portes à deux qubits - le temps nécessaire pour mettre en œuvre une opération de porte sur deux qubits adjacents. Cela peut également prendre une plage de valeurs, mais est généralement environ un ordre de grandeur plus long que pour une porte à un qubit.

Vérifions $dt$ pour notre backend, et affichons quelques plages plausibles pour les temps de porte.

print(f"Using backend: {backend.name}")

# Access the backend target
target = backend.target

def get_gate_times(target, gate_name):
    results = []

    if gate_name not in target:
        return results  # gate not supported

    # target[gate_name] is a dict: {(qubits): InstructionProperties}
    for qubits, props in target[gate_name].items():
        if props.duration is not None:
            results.append({"qubits": qubits, "duration_ns": props.duration * 1e9})

    return results

# Query some gates
for gate in ["cz", "x"]:
    times = get_gate_times(target, gate)

    print(f"\nGate: {gate}")
    if times:
        for entry in times[:5]:
            print(f"  Qubits {entry['qubits']}: {entry['duration_ns']:.2f} ns")
    else:
        print("  Not available on this backend")

Using backend: ibm_boston

Gate: cz
  Qubits (0, 1): 68.00 ns
  Qubits (1, 0): 68.00 ns
  Qubits (1, 2): 68.00 ns
  Qubits (2, 1): 68.00 ns
  Qubits (2, 3): 88.00 ns

Gate: x
  Qubits (0,): 32.00 ns
  Qubits (1,): 32.00 ns
  Qubits (2,): 32.00 ns
  Qubits (3,): 32.00 ns
  Qubits (4,): 32.00 ns

Ces temps de porte varieront d'un backend à l'autre. Nous allons coder en dur un temps de porte à deux qubits tiré de ibm_boston, de 68 ns.

dt = backend.configuration().dt
two_q_gate_time = 68e-9
print("The sampling time is : ", dt)
print("dts per T_1 : ", t1 / dt)
print("2-qubit characteristic time : ", two_q_gate_time)
print("The sampling time intervals per two-qubit gate : ", two_q_gate_time / dt)
print("2-qubit gates per T_1 : ", t1 / two_q_gate_time)

The sampling time is :  4e-09
dts per T_1 :  68425.40450045122
2-qubit characteristic time :  6.8e-08
The sampling time intervals per two-qubit gate :  17.0
2-qubit gates per T_1 :  4025.0237941441897

Garde à l'esprit qu'aucune autre source d'erreur ni leur suppression ou atténuation n'a été prise en compte ici. Les erreurs $T_1$ ne sont pas les seules erreurs à l'œuvre dans un système quantique, alors ne t'inquiète pas trop de ces chiffres. Cela signifie simplement qu'en l'absence de toute suppression, nous pourrions plausiblement mettre en œuvre de l'ordre de milliers de portes à deux qubits avant que les erreurs $T_1$ ne commencent à dominer. D'autres erreurs domineront généralement à des profondeurs bien plus faibles, et inversement, les erreurs $T_1$ pourraient encore valoir la peine d'être supprimées à des temps bien plus courts que ceux nécessaires pour effacer complètement le signal.

Nous commencerons par utiliser un simulateur avec un modèle de bruit, puis nous comparerons les résultats au matériel réel.

from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, thermal_relaxation_error
from qiskit import QuantumCircuit
from qiskit.quantum_info import Pauli
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_aer.primitives import EstimatorV2

pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=0)

Définissons un pas de temps pour nos mesures correspondant à l'estimation haute pour un temps de porte à deux qubits. Nous construirons ensuite 50 circuits par incréments de ce pas de temps. Ainsi, nous verrons ce qui se passe sur une échelle de temps similaire à la mise en œuvre de 80 portes à deux qubits. La précision n'est pas critique ici, nous n'utiliserons donc qu'une poignée de shots.

n_points = 50  # We will show 50 steps
delay_unit = 80  # The delay in units of two-qubit-time from above
shots = 100

Nous construisons un modèle de bruit pour notre simulateur qui inclut explicitement les erreurs de relaxation thermique.

# Create noise model with thermal relaxation for delays
noise_model = NoiseModel()
error = thermal_relaxation_error(
    t1, t2, two_q_gate_time * delay_unit
)  # error model characterized by times in ns
noise_model.add_all_qubit_quantum_error(error, ["delay"])

sim = AerSimulator(noise_model=noise_model)

Nous construisons maintenant nos circuits et observables. Ceux-ci sont exceptionnellement simples. Les circuits consisteront simplement à préparer le qubit dans $|1\rangle$ et à mettre en œuvre des délais pour des périodes croissantes, en utilisant les temps de porte caractéristiques et $dt$ définis ci-dessus. Les observables seront simplement $Z$, car ce que nous voulons savoir, c'est si le qubit est resté dans $|1\rangle$ ou est retombé à $|0\rangle$. Bien que la transpilation ne soit pas toujours nécessaire pour les simulateurs, nous transpilons ici nos circuits pour une utilisation ultérieure sur un backend réel.

observables = [Pauli("Z")] * n_points
circuits = []
obs = []
delay_times_sim = []
for i in range(n_points):
    qc = QuantumCircuit(1, 1)
    qc.x(0)
    if i > 0:
        for j in range(i):
            qc.delay(delay_unit * two_q_gate_time, 0, "s")
            j = j + 1
    qc_opt = pass_manager.run(qc)
    circuits.append(qc_opt)
    delay_times_sim.append(delay_unit * two_q_gate_time * i)
    observables_isa = observables[i].apply_layout(layout=qc_opt.layout)
    obs.append(observables_isa)

Nous exécutons notre job à l'aide d'un simulateur.

pubs = list(zip(circuits, obs))

# Create AerSimulator with noise model as backend
simulator = AerSimulator(noise_model=noise_model)

# Create SamplerV2 from the AerSimulator backend
estimator = EstimatorV2.from_backend(simulator)

# Run the sampler on the circuit, specify shots
job = estimator.run(pubs)
result = job.result()

Enfin, nous traçons les résultats.

# Optional: color palette similar to 'mpl', style = 'clifford'

from cycler import cycler

plt.rcParams["axes.prop_cycle"] = cycler(
    color=[
        "#4C78A8",  # muted blue
        "#72B7B2",  # teal
        "#54A24B",  # green
        "#9C89CC",  # purple
        "#B279A2",  # mauve
    ]
)

# Everything else stays at Matplotlib defaults

# Example data: assume result is a list of objects with structure result[i].data.evs.item()
# and delay_times is already defined as a list of floats.

# Extract y-values
y_sim_values = [(1 - r.data.evs.item()) / 2 for r in result]

# Use delay_times as x-values
x_sim_values = delay_times_sim

# Create the plot
plt.figure(figsize=(8, 5))
plt.plot(x_sim_values, y_sim_values, marker="o", linestyle="-", label="EV Data")

plt.xlabel("Idle Time (s)")
plt.ylabel("Probability of measuring |1>")
plt.title("T1 Decay")
plt.grid(True)
plt.show()

La décroissance exponentielle est clairement visible, et sur cette durée, elle diminue jusqu'à un peu moins de 40 % de chances d'être dans $|1\rangle$. Remarque que cela est exactement cohérent avec le modèle : $p = e^{-t/t_1}$ où nous avons choisi le $t$ maximal du même ordre que $t_1$ ; rappelle-toi que nous avons dit que $t_1$ pourrait correspondre à 60 portes (ou à cet ordre de grandeur), et qu'ici $t$ correspond à 60 portes. Ainsi

$$p \rightarrow e^{-0.25 \text{ ms}/0.267\text{ ms}} \approx 0.392$$

Exécutons maintenant les mêmes circuits sur un véritable ordinateur quantique. Afin de couvrir la même durée de délai avec moins de jobs, nous augmenterons l'unité de délai et diminuerons le nombre de points.

# This took 27 s on ibm_boston

from qiskit_ibm_runtime import EstimatorV2

# Explicitly use a pass manager with optimization level 0 so that we don't remove the delays
pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=0)

# Use the same time parameters and shots
n_points = 10
delay_unit = 400
shots = 100

# Measure Pauli Z's as your observables
observables = [Pauli("Z")] * n_points
circuits = []
obs = []
delay_times = []
for i in range(n_points):
    qc = QuantumCircuit(1, 1)
    qc.x(0)
    if i > 0:
        qc.delay(delay_unit * two_q_gate_time * i, 0, "s")
    qc_opt = pass_manager.run(qc)
    circuits.append(qc_opt)
    delay_times.append(delay_unit * two_q_gate_time * i)
    observables_isa = observables[i].apply_layout(layout=qc_opt.layout)
    obs.append(observables_isa)

pubs = list(zip(circuits, obs))
estimator = EstimatorV2(mode=backend)
job = estimator.run(pubs=pubs)
result = job.result()

# To print the job id for later retrieval of data
# job_id = job.job_id()
# print(f"Job ID: {job_id}")

Nous traçons maintenant les résultats.

fig, ax = plt.subplots()

# Convert from the expectation value of Z to the probability of a transition
y_real_values = [(1 - r.data.evs.item()) / 2 for r in result]

# Use delay_times as x-values
x_real_values = delay_times

# Exponential decay to match theoretical model
t_smooth = np.linspace(0, x_sim_values[19], 100)  # Smooth x-range covering your data
y_decay = np.exp(-t_smooth / (t1))  # y = exp(-t/t1)
ax.plot(t_smooth, y_decay, "k--", linewidth=1, label=f"Perfect Decay (t1={t1:3f} s)")

# Add simulator values
ax.scatter(x_sim_values, y_sim_values, label="Simulator", alpha=0.7)

# Add real QC values
ax.scatter(x_real_values, y_real_values, label="Real", alpha=0.7)

# Add labels and plot
ax.set_xlabel("Idle Time (s)")
ax.set_ylabel("Probability of measuring |1>")
ax.legend()
ax.set_title("T1 Decay")
ax.grid(True)

plt.show()

Comme nous pouvons le voir, la décroissance de l'état $|1\rangle$ au fil du temps correspond à la théorie (et à la définition de $T_1$). De plus, le simulateur reproduit assez bien le comportement de l'ordinateur quantique réel dans ce cas. Voici quelques points à garder à l'esprit concernant la décroissance de cet état :

• Nous avons artificiellement retardé la mesure pendant une durée irréaliste. Ces délais correspondent à l'échelle de temps de circuits extrêmement profonds pouvant comporter des milliers de portes à deux qubits. Cela a été fait uniquement pour montrer que les effets du bruit thermique existent. Dans des circuits réels appliqués à des problèmes du monde réel, des opérations seraient effectuées sur d'autres qubits pendant qu'une poignée pourrait rester inactive assez longtemps pour que les erreurs de relaxation énergétique importent — mais d'autres erreurs domineraient avant d'atteindre un $T_1$ complet.
• Aucune technique d'atténuation ou de suppression des erreurs n'a été utilisée. Nous pouvons modifier cette courbe de décroissance en utilisant les techniques que nous apprendrons dans ce cours.
• Nous n'avons utilisé que 100 shots ici, ce qui est inhabituellement faible car nous cherchions uniquement à démontrer que l'effet existe. Tu utiliseras probablement plus de 1 000 shots dans les applications.

Cette première visualisation d'erreur n'a nécessité presque aucune porte autre que des délais (et la porte X unique utilisée pour préparer $|1\rangle$). Examinons maintenant un autre exemple portant sur l'erreur de porte.

Erreurs de porte et accumulation

Lorsque nous appliquons une porte quantique, disons une porte $X$, en théorie cette porte fait tourner un état quantique d'un angle $\pi$ radians autour de l'axe $X$ sur la sphère de Bloch, transformant $\alpha |0\rangle + \beta |1\rangle$ en $\alpha |1\rangle + \beta |0\rangle$ via

$$\begin{aligned} X|\psi\rangle & = R_X(\pi) |\psi\rangle\\ & = \begin{pmatrix} \cos{(\theta/2)} & -i \sin{(\theta/2)} \\ -i \sin{(\theta/2)} & \cos{(\theta/2)} \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & = \begin{pmatrix} 0 & 1 \\ 1 & 0 \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & =\begin{pmatrix} \beta \\ \alpha \end{pmatrix}\\ \end{aligned}$$

Cependant, une porte réelle est imparfaite. Elle peut être mal orientée (ce qui entraîne des rotations qui ne sont pas parfaitement autour de l'axe X) ou elle peut provoquer une rotation légèrement plus grande ou plus petite que prévu. Modélisons une erreur de porte comme étant purement une sur/sous-rotation d'un petit angle $\epsilon$.

$$\begin{aligned} X_\epsilon|\psi\rangle & = R_X(\pi+\epsilon) |\psi\rangle\\ & = \begin{pmatrix} \cos{(\theta+\epsilon/2)} & -i \sin{(\theta+\epsilon/2)} \\ -i \sin{(\theta+\epsilon/2)} & \cos{(\theta+\epsilon/2)} \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & \approx \begin{pmatrix} \epsilon & 1-\epsilon^2/2 \\ 1-\epsilon^2/2 & \epsilon \end{pmatrix}\begin{pmatrix} \alpha \\ \beta \end{pmatrix}\\ & =\begin{pmatrix} \epsilon \alpha+(1-\epsilon^2/2)\beta \\ (1-\epsilon^2/2)\alpha+\epsilon \beta \end{pmatrix}\\ \end{aligned}$$

Si une porte imparfaite est appliquée plusieurs fois, de petites erreurs $\epsilon$ peuvent s'accumuler. Parfois, ces erreurs multiples font même dévier l'état dans la même direction à chaque fois (un phénomène appelé « accumulation cohérente », que nous reverrons plus loin). Voyons ce qui se passe lorsque nous appliquons une véritable porte X à un qubit plusieurs fois.

# This took 78 s on penguino1

from qiskit_ibm_runtime import EstimatorV2

# Explicitly use a pass manager with optimization level 0 so that we don't remove the delays
pass_manager = generate_preset_pass_manager(backend=backend, optimization_level=0)

# Use the same bit flips
max_depth = 60
circuits = []
observables = []

for depth in range(max_depth + 1):
    qc = QuantumCircuit(1)
    # Repeat flipping back and forth depth times
    for _ in range(depth):
        #    qc.x(0)
        qc.x(0)
        qc.barrier()
        qc.x(0)
        qc.barrier()
    circuits.append(qc)
    observables.append(Pauli("Z"))

pubs = list(zip(circuits, observables))

estimator = EstimatorV2(mode=backend)
results = estimator.run(pubs=pubs).result()
real_expectations = [pub_res.data.evs for pub_res in results]

# from qiskit_ibm_runtime import QiskitRuntimeService

# service = QiskitRuntimeService()           # uses stored IBM Quantum account
# job_id = "d5immof67pic7386l8eg"

# job = service.job(job_id)                 # retrieve the job
# results = job.result()                        # this is your .result() object

# Convert from the expectation value of Z to the probability of a transition
# y_real_values = [(1-r.data.evs.item())/2 for r in results]

# Create the plot
plt.figure(figsize=(8, 5))
# plt.plot(range(max_depth + 1), y_real_values, 'o-')
# plt.plot(x_real_values, y_real_values, marker='o', linestyle='-', color='blue', label='EV Data')
plt.plot(
    range(max_depth + 1),
    real_expectations,
    marker="o",
    linestyle="-",
    color="blue",
    label="EV Data",
)

plt.xlabel("Number of Flip-Back Cycles")
plt.ylabel("Expectation ⟨Z⟩")
plt.title("Accumulated Gate Noise Effects on Flips")
plt.grid(True)
plt.show()

La valeur d'espérance commence autour de 1,0 comme prévu, puis décroît, mais elle ne décroît pas simplement jusqu'à zéro ! Elle devient négative. S'il s'agissait de bruit thermique ou d'interactions aléatoires, cela ne rendrait pas $|1\rangle$ plus susceptible d'être mesuré que $|0\rangle$. Cette erreur est clairement différente. Et cela a du sens dans le contexte de notre discussion sur la sur/sous-rotation. Si chaque paire de rotations censée s'annuler finit en réalité par tourner d'un petit angle, alors de nombreuses répétitions de ce type permettraient à l'état de tourner lentement de $|0\rangle$ vers $|1\rangle$.

L'accumulation d'erreurs présentée ici ne se déroulera probablement pas de manière aussi nette dans un flux de travail réel. D'une part, nous avons explicitement désactivé l'atténuation des erreurs et exécuté la même séquence de portes répétitive pour permettre aux erreurs de s'accumuler de manière cohérente. Cela est fait uniquement pour démontrer que ces erreurs existent. Lorsque nous utilisons des techniques de gestion du bruit (par exemple, le Pauli twirling), nous pouvons influencer la façon dont l'erreur s'accumule, ce qui donne souvent une erreur globale plus faible.

Nous pouvons vérifier précisément dans quelle mesure notre modèle de cette erreur correspond aux données expérimentales en construisant explicitement un modèle de bruit et en utilisant un simulateur. Dans le modèle ci-dessous, nous intégrons explicitement une erreur correspondant à 0,025 radian. Ce n'est pas un nombre magique ; on peut simplement ajuster l'erreur jusqu'à ce qu'elle décrive raisonnablement l'expérience.

from qiskit_aer.noise import NoiseModel, coherent_unitary_error
from qiskit_aer import AerSimulator
import numpy as np

# For your SINGLE-QUBIT test on qubit 0, just override X error specifically
noise_model = NoiseModel.from_backend(backend, gate_error=True, thermal_relaxation=True)

theta_error = 0.025  # model over-rotation error around 0.01-0.03 radians
U_over = np.array(
    [
        [np.cos(theta_error / 2), -1j * np.sin(theta_error / 2)],
        [-1j * np.sin(theta_error / 2), np.cos(theta_error / 2)],
    ]
)

unitary_error = coherent_unitary_error(U_over)
# Target ONLY qubit 0 (your circuit) - no warning!
noise_model.add_quantum_error(unitary_error, ["x"], [0])

simulator = AerSimulator(noise_model=noise_model)

WARNING: quantum error already exists for instruction "x" on qubits (0,) , appending additional error.

max_depth = 60
circuits = []
observables = []

for depth in range(max_depth + 1):
    qc = QuantumCircuit(1)
    # Repeat flipping back and forth depth times
    for _ in range(depth):
        #    qc.x(0)
        qc.x(0)
        qc.barrier()
        qc.x(0)
        qc.barrier()
    circuits.append(qc)
    observables.append(Pauli("Z"))

pubs = list(zip(circuits, observables))

estimator = EstimatorV2.from_backend(simulator)
results = estimator.run(pubs).result()
expectations = [pub_res.data.evs for pub_res in results]  # no [0], use value directly

Nous pouvons maintenant tracer ensemble les courbes réelle et simulée.

fig, ax = plt.subplots()

# Add simulator values
ax.scatter(range(max_depth + 1), expectations, c="blue", label="Simulator", alpha=0.7)

# Add real QC values
ax.scatter(range(max_depth + 1), real_expectations, c="red", label="Real", alpha=0.7)

# Add labels and plot
ax.set_xlabel("Number of Flip-Back Cycles")
ax.set_ylabel("Expectation ⟨Z⟩")
ax.set_title("Accumulated Gate Noise Effects on Flips")
ax.legend()
ax.grid(True)

plt.show()

L'erreur dans le circuit réel était assez bien décrite par le modèle d'erreur de sur/sous-rotation. Il est clair que différents types de bruit et d'erreurs s'accumulent différemment et entraînent des effets radicalement différents sur la fidélité de nos circuits quantiques. Il devient donc très important de classer et de caractériser les erreurs pouvant survenir de manière plus formelle que nous ne l'avons fait jusqu'à présent.

Caractériser les erreurs quantiques

Nous avons déjà décrit certaines des sources de bruit quantique, et nous pourrions classer les erreurs selon les catégories de bruit qui les causent. Mais il pourrait exister différentes catégories d'erreurs quantiques utiles pour la correction et l'atténuation d'erreurs. Par exemple, nous devons savoir à quel moment les erreurs se produisent et comment elles s'accumulent si nous voulons les corriger ou les atténuer. Pour préciser où (dans quels processus) les erreurs se produisent, une catégorie importante et courante est celle des erreurs de préparation d'état et de mesure (ou erreurs SPAM, pour faire court). Ici, le terme « préparation d'état » ne désigne pas tout ce qui est fait sur un état pour le préparer à la mesure. Il fait plutôt référence à l'initialisation des qubits, à la « préparation » des qubits en vue de l'exécution d'un algorithme, et cette catégorie SPAM exclut donc des éléments tels que les erreurs de porte survenant pendant l'exécution de l'algorithme.

Une autre distinction importante est de savoir si les erreurs sont cohérentes ou incohérentes. Pour résumer brièvement (nous les aborderons plus en détail ci-dessous), les erreurs cohérentes sont typiquement modélisées par des opérations unitaires et préservent la pureté de l'état. Les erreurs incohérentes sont modélisées par des canaux quantiques non unitaires et réduisent généralement la pureté de l'état. Il est facile de visualiser les erreurs incohérentes comme des interactions thermiques entraînant une perte d'information quantique, mais elles pourraient en réalité être causées par n'importe quel couplage aléatoire avec l'environnement. Pour donner un exemple d'erreur cohérente, supposons qu'il existe une imperfection dans l'orientation de l'impulsion lors de la mise en œuvre d'une porte RY, telle qu'une porte $RY(\theta)$ provoque en réalité $RY(\theta) \cdot RX(\epsilon)$. Une telle imperfection provoquerait toujours une rotation erronée autour de X dans la même direction. Il s'agirait alors d'une erreur cohérente.

Note que les erreurs SPAM comprennent un mélange d'erreurs cohérentes, comme des défauts de contrôle systématiques, et d'erreurs incohérentes, comme la perte de photons et les effets thermiques. Comme cela implique plusieurs étapes et sources d'erreurs, les erreurs SPAM sont mieux décrites comme une combinaison d'erreurs cohérentes et incohérentes.

Erreurs SPAM

Comme leur nom l'indique, les erreurs SPAM apparaissent à deux étapes distinctes d'une expérience quantique : la préparation initiale et la lecture/mesure. Les erreurs de préparation d'état se produisent lorsque le matériel ne parvient pas à initialiser de manière fiable les qubits dans l'état de départ souhaité ($|0\rangle$ pour les ordinateurs quantiques IBM). Les causes incluent :

• l'excitation thermique (les qubits réels ne sont pas parfaitement refroidis et peuvent occasionnellement démarrer dans $|1\rangle$ au lieu de $|0\rangle$)
• des photons résiduels ou du bruit dans les résonateurs des qubits supraconducteurs
• des dérives d'étalonnage qui affectent la précision avec laquelle les qubits sont réinitialisés

Les erreurs de mesure se produisent pendant le processus de lecture, lorsque l'appareil de mesure identifie mal l'état du qubit. Les sources incluent :

• le bruit de l'amplificateur de lecture provoquant une confusion entre $|0\rangle$ et $|1\rangle$

• la relaxation du qubit pendant la lecture (par exemple, un qubit dans $|1\rangle$ se désexcite vers $|0\rangle$ juste avant ou pendant la mesure)

• la diaphonie entre les lignes de lecture : la lecture d'un qubit influence légèrement les lectures des qubits voisins

• des seuils de discrimination imparfaits dans les systèmes de mesure d'IBM basés sur des résonateurs

Les erreurs SPAM sont principalement incohérentes. Les erreurs de préparation se comportent comme des mélanges aléatoires d'états excités et fondamentaux. Les erreurs de mesure se comportent comme une confusion classique : avec une probabilité $p$, $|0\rangle$ est signalé comme $|1\rangle$ ou vice versa. Elles se distinguent des erreurs unitaires cohérentes (comme des portes mal calibrées provoquant des déphasages systématiques). Les erreurs SPAM ressemblent plutôt à du bruit classique aléatoire, bien que de rares biais cohérents en lecture puissent exister.

Les erreurs SPAM peuvent poser problème pour l'analyse comparative aléatoire (randomized benchmarking) ou pour les circuits de faible profondeur, où la préparation d'état et la mesure représentent une grande partie de l'erreur totale. Elles posent moins problème pour les circuits très profonds, en particulier ceux comportant de nombreuses portes à deux qubits.

Mathématiquement, les erreurs SPAM peuvent être décrites comme produisant une distribution bruitée $\vec{p}_\text{noisy}$ qui est liée à la distribution idéale $\vec{p}_\text{ideal}$ par une matrice $A$ :

$$\vec{p}_\text{noisy} = A \vec{p}_\text{ideal}$$

Ici, $p_i$ est la probabilité de mesurer la chaîne de bits $i$, et $A_{ij}$ est la probabilité d'obtenir l'état $j$ alors que l'état aurait dû être préparé dans l'état $i$. Imagine le contexte des chaînes de bits échantillonnées par Sampler. Ta distribution d'états mesurée sera constituée de nombreuses mesures précises, mais aussi de certaines mesures pour lesquelles les instructions de préparation d'état ne correspondent pas à l'état observé. Cela signifie que les probabilités seront légèrement décalées.

Dans la figure ci-dessus, la partie (a) montre la distribution idéale d'un état GHZ en bleu sarcelle, et les mesures réelles en violet. Dans la partie (b), nous voyons un exemple de matrice $A$. Note que la matrice n'est pas parfaitement symétrique par rapport à la diagonale, car chaque qubit n'a pas nécessairement la même probabilité de renvoyer à tort un 0 que de renvoyer à tort un 1. En pratique, il est souvent difficile de séparer les erreurs de préparation et de lecture, c'est pourquoi elles sont souvent regroupées dans un traitement unique (d'où l'usage courant du terme SPAM).

Une façon de corriger ces erreurs SPAM consiste à utiliser des circuits simples dont les résultats de mesure idéaux sont connus, et à les comparer aux résultats mesurés en présence d'erreurs SPAM. Cela peut permettre de déduire par rétro-ingénierie les résultats idéaux de circuits plus complexes. Pour des états généraux à haute entropie, cela pourrait nécessiter la construction d'une matrice de $2^N\times2^N$ probabilités, mais dans des cas moins extrêmes, ces erreurs peuvent être atténuées.

Erreurs cohérentes versus erreurs incohérentes

Les erreurs cohérentes sont des mauvaises rotations systématiques, déterministes et unitaires de l'état quantique. Elles proviennent d'opérations quantiques imparfaites qui dévient de manière prévisible. Parmi les exemples figurent de légères erreurs de rotation appliquées par des portes de rotation à un qubit, y compris celles causées par une dérive d'étalonnage qui entraînerait systématiquement une sur- ou sous-rotation. Mathématiquement, nous pourrions écrire qu'une porte de rotation réelle, disons $\tilde{R_X}(\theta)$, est donnée par la porte de rotation idéale plus une erreur supplémentaire :

$$\tilde{R_X}(\theta) = R_X(\theta + \epsilon)$$

pour une petite sous- ou sur-rotation $\epsilon$. D'autres exemples incluent une porte à deux qubits ajoutant un petit déphasage indésirable, ainsi que des impulsions de contrôle qui dévient systématiquement de la forme idéale.

Une caractéristique clé des erreurs cohérentes est qu'elles sont déterministes et peuvent elles-mêmes être modélisées par des portes unitaires. En conséquence, elles préservent la pureté de l'état quantique : l'information quantique n'est pas perdue, elle a simplement été traitée de manière imparfaite. Un autre point important à noter est que les erreurs cohérentes répétées interfèrent de manière constructive et croissent parfois de façon quadratique avec le nombre de portes.

Ces erreurs sont parfois prévisibles et peuvent donc être en partie éliminées par étalonnage. Mais les erreurs cohérentes qui subsistent peuvent s'accumuler rapidement, provoquant des écarts gênants par rapport aux états idéaux. Cela signifie qu'il est parfois avantageux de « randomiser » intentionnellement les erreurs cohérentes. Cette procédure et son utilité seront abordées dans la leçon sur l'atténuation des erreurs.

Pourquoi elles posent problème

Les erreurs cohérentes peuvent « s'accumuler » de manière dangereuse, produisant des écarts importants par rapport à l'état correct si elles ne sont pas randomisées ou corrigées.

Les erreurs incohérentes sont stochastiques, aléatoires et souvent non unitaires. Elles proviennent d'interactions avec l'environnement ou de sources de bruit incontrôlées. Nous en avons déjà vu quelques exemples : la relaxation d'énergie / la décroissance $T_1$ est incohérente. Il en va de même pour le bruit de porte stochastique, le bruit thermique et l'erreur de mesure.

La caractéristique clé des erreurs incohérentes est qu'elles ne sont pas les mêmes à chaque fois qu'une opération est effectuée. Elles sont non unitaires et ne peuvent donc pas être modélisées par une simple porte quantique unitaire, contrairement aux erreurs cohérentes. Parce qu'elles sont incohérentes, elles s'accumulent généralement de manière linéaire, comme du bruit aléatoire, et non comme une sur-rotation constante.

Les erreurs incohérentes font perdre irréversiblement de l'information aux qubits (perte de pureté et d'information de phase).

Alors, lesquelles sont pires ? Comme pour la plupart des choses en informatique quantique, cela dépend. Ce qu'il faut retenir, c'est que les erreurs cohérentes s'accumulent plus rapidement et de façon non linéaire (ce qui est mauvais). Mais elles peuvent être en partie éliminées par étalonnage, et l'information de phase est toujours présente dans ton système, si tu parviens à déterminer comment l'extraire correctement. Les erreurs incohérentes s'accumulent de manière linéaire, ce qui est avantageux pour deux raisons : c'est plus lent que l'accumulation cohérente, et il est assez facile de voir comment les effets des erreurs incohérentes évoluent pour des processus comme l'extrapolation à bruit nul (ZNE), qui sera abordée dans la leçon sur l'atténuation des erreurs. Cependant, lorsque des erreurs incohérentes se produisent, l'information quantique est véritablement perdue, et non simplement masquée.

Matrices de densité et canaux quantiques

Dans les sections suivantes, nous approfondirons quelques types d'erreurs cohérentes et incohérentes et verrons comment elles peuvent être modélisées mathématiquement à l'aide de canaux quantiques. Tout d'abord, un bref rappel sur les matrices de densité et les canaux quantiques s'impose. Pour un traitement complet et rigoureux de ces sujets, consulte le cours de John Watrous General formulation of quantum information sur IBM Quantum Learning. Le traitement proposé ici sera davantage axé sur des exemples et moins formel.

Les canaux quantiques constituent la manière la plus générale de décrire comment un système quantique évolue, interagit et subit du bruit. Si tu as l'habitude des états purs et de l'évolution unitaire, les canaux quantiques en sont la suite naturelle.

En mécanique quantique standard, un état « pur » s'écrit $|\psi\rangle$. Ici, « pur » fait référence à la pureté de l'information ou à la connaissance de la préparation de l'état ; cela ne signifie pas un état propre d'un système quelconque. Pour un exemple de qubit, $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ est un état pur car nous avons une connaissance parfaite des amplitudes relatives et de la phase. L'évolution temporelle d'un tel état pur est régie par un opérateur unitaire $U$ :

$$|\psi\rangle \rightarrow U|\psi\rangle$$

selon l'équation de Schr"odinger, dans laquelle $U = e^{-iHt/\hbar}$, où $H$ est l'hamiltonien du système et $\hbar$ est la constante de Planck réduite, souvent « posée égale à un », ou plus rigoureusement, absorbée dans l'hamiltonien de sorte que toutes les énergies soient exprimées en unités de $\hbar$.

L'évolution unitaire est réversible, déterministe et isolée. Mais cela est insuffisant pour décrire les systèmes quantiques réels. Dans les systèmes quantiques réels :

• Nous effectuons des mesures, faisant s'effondrer l'état quantique dans un état propre du système. Il s'agit explicitement d'un processus non unitaire.
• Le système interagit avec un environnement. Cela signifie que le système n'est pas véritablement isolé, et comme l'environnement ne peut pas être suivi à l'infini, cela correspond à une perte d'information.
• En pratique : le bruit corrompt l'état. Et bien d'autres choses encore.

L'évolution unitaire seule ne peut pas décrire ces processus ; nous avons donc besoin d'une représentation plus générale des états et processus quantiques. Un état mixte décrit une distribution classique d'états quantiques. C'est-à-dire que nous savons déjà que l'état quantique : $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ a 50 % de chances d'être mesuré (effondré en information classique) dans l'état $|0\rangle$ et 50 % de chances d'être mesuré dans $|1\rangle$. Mais l'affirmation est que l'état quantique initial est exactement $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ avec une probabilité de 100 %. Nous voulons maintenant ajouter, en plus de la probabilité de mécanique quantique, une probabilité classique, par exemple :

L'état quantique initial est préparé dans $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ avec une probabilité classique de 25 %, et est préparé dans $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle-i|1\rangle)$ avec une probabilité classique de 75 % (note les phases relatives différentes).

Cela peut parfois être dû à des probabilités classiques explicites dans la préparation ; d'autres fois, cela peut être dû à l'intrication avec des parties de l'environnement que nous ignorons. Dans tous les cas, le besoin d'un outil pour décrire cette distribution classique d'états quantiques est évident. Les états purs seuls ne peuvent pas représenter ces possibilités. Nous introduisons donc la matrice de densité.

Un état mixte est décrit par un opérateur de densité :

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

Ici, $|\psi_i\rangle$ est un état quantique (pas nécessairement un état propre d'un opérateur particulier) et $p_i$ est la probabilité classique que le système soit préparé dans l'état $|\psi_i\rangle$. Il s'agit d'une bonne recette pour construire une matrice de densité à partir d'une distribution classique connue d'états quantiques. D'un autre côté, nous pourrions vouloir savoir, étant donné à la fois une distribution classique d'états quantiques et une probabilité de mécanique quantique pour différents résultats de mesure, quelle est la probabilité qu'une mesure donne un état particulier (comme $|0\rangle$, ou $|1\rangle$, ou d'autres états lorsque davantage de qubits sont impliqués). C'est là que la matrice de densité est particulièrement utile. Nous pouvons aussi l'écrire dans une base $\{|i\rangle\}$ comme :

$$\rho = \sum_{i,j} \rho_{ij} |i\rangle\langle j|.$$

Ici, les éléments diagonaux $\rho_{ii}$​ sont des probabilités :

• $\rho_{00}$​ = probabilité que le qubit soit dans $|0\rangle$

• $\rho_{11}$​ = probabilité que le qubit soit dans $|1\rangle$

Ils sont réels, non‑négatifs, et leur somme vaut 1.

Les éléments hors diagonale $\rho_{ij}, i \neq j$ sont des cohérences : des relations de phase ou une capacité d'interférence, et correspondent généralement à la quantité d'information de mécanique quantique présente dans l'état. Il s'agit d'une affirmation informelle, mais voyons ce que cela signifie en pratique.

Exemple

Considère l'état pur $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. (a) Que sais-tu des probabilités de mesure et de l'information de phase sans faire de calcul ? (b) Construis la matrice de densité et vérifie ton intuition.

Solution:

(a) Puisqu'il s'agit d'un état pur, il n'existe qu'une seule phase possible entre $|0\rangle$ et $|1\rangle$ : +1. Il s'agit d'une information de phase parfaite, nous nous attendons donc à ce que les éléments hors diagonale de notre matrice de densité soient grands. Tu as peut-être une intuition plus poussée à ce sujet, mais cela suffit pour l'instant. De plus, les amplitudes des deux états de base sont égales, nous nous attendons donc à une probabilité de 50 % de mesurer $|0\rangle$ ou $|1\rangle$. Nous nous attendons donc à ce que les entrées diagonales valent 1/2. (b) En utilisant la définition ci-dessus :

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ uniquement pour l'état $|\psi\rangle$. Nous pouvons donc écrire

$$\begin{aligned} \rho & = 1 |\psi\rangle\langle\psi| \\ & = \frac{1}{2}(|0\rangle+|1\rangle)(\langle0|+\langle1|)\\ & =\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}. \end{aligned}$$

Les entrées diagonales valent chacune $1/2$ comme prévu, et les éléments hors diagonale sont grands (leur somme vaut un).

Voyons maintenant ce qui se passe lorsque nous n'avons pas une bonne information de phase.

Exemple

Considère un cas similaire, mais cette fois avec une probabilité classique de 50 % d'être dans l'état $|\psi_+\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ et une probabilité classique de 50 % d'être dans l'état $|\psi_-\rangle = \frac{1}{\sqrt{2}}(|0\rangle-|1\rangle)$. Mêmes deux questions : (a) Que sais-tu des probabilités de mesure et de l'information de phase sans faire de calcul ? (b) Construis la matrice de densité et vérifie ton intuition.

Solution:

(a) Comme précédemment, les amplitudes des deux états de base sont égales, nous nous attendons donc à une probabilité de 50 % de mesurer $|0\rangle$ ou $|1\rangle$. Nous nous attendons donc à ce que les entrées diagonales valent 1/2. Mais cette fois, il existe deux possibilités opposées pour la phase entre $|0\rangle$ et $|1\rangle$ : +1 et -1, chacune étant également probable. On pourrait s'attendre à ce qu'avec deux phases opposées également probables, on ait peu voire aucune information de phase. On pourrait s'attendre à ce que les entrées hors diagonale soient petites. (b) En utilisant à nouveau la définition ci-dessus

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ uniquement pour les deux états $|\psi_+\rangle$ et $|\psi_-\rangle$. Nous pouvons donc écrire

$$\begin{aligned} \rho & = \frac{1}{2} |\psi_+\rangle\langle\psi_+| + \frac{1}{2}|\psi_-\rangle\langle\psi_-| \\ & = \frac{1}{4}(|0\rangle+|1\rangle)(\langle0|+\langle1|)+\frac{1}{4}(|0\rangle-|1\rangle)(\langle0|-\langle1|)\\ & =\frac{1}{4}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}+\frac{1}{4}\begin{pmatrix} 1 & -1 \\ -1 & 1\end{pmatrix}\\ & =\frac{1}{2}\begin{pmatrix} 1 & 0 \\ 0 & 1\end{pmatrix}. \end{aligned}$$

Les entrées hors diagonale sont petites, nulles en fait, comme prévu. Les éléments diagonaux valent toujours 50 % chacun, ce qui a du sens car chacun des états du mélange avait $|0\rangle$ et $|1\rangle$ pondérés de manière égale.

Cette construction devient plus intéressante à mesure que le nombre de qubits augmente. Explore cela dans les questions ci-dessous.

Vérifie ta compréhension

Écris la matrice de densité pour l'état de Bell pur $|\Phi_+\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$.

Réponse

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ uniquement pour l'état $|\Phi_+\rangle$. Nous pouvons donc écrire

$$\begin{aligned} \rho & = 1 |\Phi_+\rangle\langle\Phi_+| \\ & = \frac{1}{2}(|00\rangle+|11\rangle)(\langle00|+\langle11|)\\ & =\frac{1}{2}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}. \end{aligned}$$

Écris la matrice de densité pour une probabilité classique de 25 % de $|\Phi_\text{+}\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$ et une probabilité classique de 75 % de $|\Psi_\text{-}\rangle = \frac{1}{\sqrt{2}}(|01\rangle-|10\rangle)$.

Réponse

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ uniquement pour les deux états $|\Phi_+\rangle$ et $|\Psi_-\rangle$. Nous pouvons donc écrire

$$\begin{aligned} \rho & = \frac{1}{4} |\Phi_+\rangle\langle\Phi_+| + \frac{3}{4}|\Psi_-\rangle\langle\Psi_+| \\ & = \frac{1}{8}(|00\rangle+|11\rangle)(\langle00|+\langle11|)+\frac{3}{8}(|01\rangle-|10\rangle)(\langle01|-\langle10|)\\ & =\frac{1}{8}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}+\frac{3}{8}\begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 1 & -1 & 0 \\ 0 & -1 & 1 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix}\\ & =\frac{1}{8}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 3 & -3 & 0 \\ 0 & -3 & 3 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}. \end{aligned}$$

Modifie ton travail de la question précédente pour écrire la matrice de densité pour une probabilité classique de 50 % de $|\Phi_\text{+}\rangle = \frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$ et une probabilité classique de 50 % de $|\Psi_\text{-}\rangle = \frac{1}{\sqrt{2}}(|01\rangle-|10\rangle)$. Prédis quelle information de phase devrait persister.

Réponse

$$\rho = \sum_i p_i |\psi_i\rangle\langle\psi_i|.$$

$p_i \neq 0$ uniquement pour les deux états $|\Phi_+\rangle$ et $|\Psi_-\rangle$. Nous pouvons donc écrire

$$\begin{aligned} \rho & = \frac{1}{2} |\Phi_+\rangle\langle\Phi_+| + \frac{1}{2}|\Psi_-\rangle\langle\Psi_-| \\ & = \frac{1}{4}(|00\rangle+|11\rangle)(\langle00|+\langle11|)+\frac{1}{4}(|01\rangle-|10\rangle)(\langle01|-\langle10|)\\ & =\frac{1}{4}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}+\frac{1}{4}\begin{pmatrix} 0 & 0 & 0 & 0 \\ 0 & 1 & -1 & 0 \\ 0 & -1 & 1 & 0 \\ 0 & 0 & 0 & 0 \end{pmatrix}\\ & =\frac{1}{4}\begin{pmatrix} 1 & 0 & 0 & 1 \\ 0 & 1 & -1 & 0 \\ 0 & -1 & 1 & 0 \\ 1 & 0 & 0 & 1 \end{pmatrix}. \end{aligned}$$

Les termes diagonaux ont une somme égale à 1, comme il se doit. Les termes hors diagonale ne s'annulent pas ici comme c'était le cas dans un exemple précédent à un qubit. Tu peux en voir la raison dans les calculs, mais une explication résumée est qu'il y a maintenant davantage d'états dans notre espace de Hilbert. Bien que le premier état de Bell ait une phase relative positive et le second une phase négative, ces phases se situaient entre des états de base différents. Le premier état de Bell avait une phase entre $|00\rangle$ et $|11\rangle$, tandis que le second avait une phase relative entre $|01\rangle$ et $|10\rangle$.

Canaux quantiques

Un canal quantique est la transformation physiquement autorisée la plus générale d'un état quantique. Il fait passer une matrice de densité initiale $\rho$ à une autre matrice de densité :

$$\rho \quad \longrightarrow \Phi(\rho)$$

Ici, $\Phi(\rho)$ désigne un canal quantique $\Phi$ agissant sur une matrice de densité $\rho$, à ne pas confondre avec les états de Bell $|\Phi_+\rangle$ ou $|\Phi_-\rangle$.

Les canaux quantiques sont extrêmement généraux. Ils peuvent inclure :

• L'évolution unitaire $\Phi(\rho) = U\rho U^\dagger$

• Des mélanges probabilistes d'unitaires

• Measurements

• Decoherence

• L'amortissement d'amplitude (perte d'énergie)

• Le déphasage (perte d'information de phase)

• L'interaction avec un environnement Et bien d'autres choses encore.

Une façon de concevoir les canaux quantiques est de dire qu'ils sont aux matrices de densité ce que les unitaires sont aux états purs. Mais la généralité des matrices de densité permet aux canaux quantiques correspondants d'être beaucoup plus généraux, et donc plus puissants.

Les seules contraintes imposées à un canal quantique sont qu'il doit être :

1. Linéaire Les mélanges d'états doivent évoluer de manière cohérente : $\Phi(p\rho_1 + (1-p)\rho_2) = p\Phi(\rho_1) + (1-p)\Phi(\rho_2)$
2. Complètement positif Il ne doit pas produire de probabilités négatives, même si ton système est intriqué avec autre chose.
3. Préservant la trace Les probabilités doivent totaliser 1. Ces propriétés sont parfois regroupées dans l'acronyme CPTP : applications complètement positives préservant la trace (Completely Positive Trace-Preserving maps).

Il existe différentes représentations des canaux quantiques, notamment les représentations de Stinespring, de Kraus et de Choi. Elles sont traitées en détail dans cette leçon sur les canaux quantiques dans General formulation of quantum information, où il est également montré qu'elles sont équivalentes. Nous n'entrerons pas dans le détail de ces différentes représentations ici. Il suffit de dire qu'elles sont analogues à la description de vecteurs à l'aide de trois systèmes de coordonnées différents. Chacune peut mettre l'accent sur des aspects différents et développer l'intuition d'une manière différente ; mais elles donnent toutes la bonne réponse. Les représentations de Kraus sont pratiques pour nos besoins. Elles offrent un moyen formulaire pratique d'exprimer l'action d'un canal par multiplication et addition matricielles. En particulier, une représentation de Kraus est une spécification d'un canal, $\Phi$, sous la forme suivante.

$$\Phi(\rho) = \sum_{k = 0}^{N-1} A_k \rho A_k^{\dagger}$$

Ici, $A_0,\ldots,A_{N-1}$ sont des matrices qui ont toutes les mêmes dimensions : leurs colonnes correspondent aux états classiques du système d'entrée, $\mathsf{X}$, et leurs lignes correspondent aux états classiques du système de sortie, qu'il s'agisse de $\mathsf{X}$ ou d'un autre système $\mathsf{Y}$. Pour que $\Phi$ soit un canal valide, ces matrices doivent satisfaire la condition suivante.

$$\sum_{k = 0}^{N-1} A_k^{\dagger} A_k = \mathbb{I}_{\mathsf{X}}$$

Ces matrices sont appelées matrices de Kraus. Cette formulation s'applique non seulement aux canaux de bruit, mais aussi aux processus et canaux quantiques en général, y compris la mesure. Voyons un exemple de la façon dont elles peuvent être utilisées pour construire des canaux dans le contexte du bruit et des erreurs.

Canal complètement déphasant

Considère un canal qui détruit toute information de phase et appelons-le le canal complètement déphasant. Cela signifie que le canal doit transformer toute matrice de densité de la forme

$$\rho_i = \begin{pmatrix} \rho_{11} & \rho_{12} & \dots & \rho_{1n} \\ \rho_{21} & \rho_{22} & \ddots & \rho_{2n} \\ \vdots & \ddots & \ddots & \vdots \\ \rho_{n1} & \rho_{n2} & \dots & \rho_{nn} \end{pmatrix}$$

en

$$\rho_f = \Phi(\rho_i) = \begin{pmatrix} \rho_{11} & 0 & \dots & 0 \\ 0 & \rho_{22} & \ddots & 0 \\ \vdots & \ddots & \ddots & \vdots \\ 0 & 0 & \dots & \rho_{nn} \end{pmatrix}$$

Si nous supposons que la matrice de densité a déjà été écrite dans la base de calcul, nous pouvons exprimer $\rho_{ij}$ comme $\langle i|\rho|j\rangle$. Cela suggère un ensemble de matrices de Kraus permettant de réaliser cette action de canal : $A_k = |k\rangle\langle k|$. Appliquons cette stratégie à un exemple avec un seul qubit, et voyons si elle fonctionne comme nous l'exigeons :

Pose $A_0 = \vert 0\rangle\langle 0\vert$ et $A_1 = \vert 1\rangle\langle 1\vert$.

$$\begin{aligned} \sum_{k = 0}^1 A_k \rho A_k^{\dagger} & = \vert 0\rangle\langle 0 \vert \rho \vert 0\rangle\langle 0 \vert + \vert 1\rangle\langle 1 \vert \rho \vert 1\rangle\langle 1 \vert \end{aligned}$$

Comme $\langle 0 \vert \rho \vert 0\rangle$ est un nombre, nous pouvons simplement déplacer le vecteur $\vert 0\rangle$ au-delà. Cela s'applique également au second terme. Nous avons :

$$\begin{aligned} \sum_{k = 0}^1 A_k \rho A_k^{\dagger}& = \langle 0 \vert \rho \vert 0\rangle \, \vert 0\rangle\langle 0 \vert + \langle 1 \vert \rho \vert 1\rangle \, \vert 1\rangle\langle 1 \vert \\[2mm] & = \begin{pmatrix} \langle 0 \vert \rho \vert 0 \rangle & 0 \\[1mm] 0 & \langle 1 \vert \rho \vert 1 \rangle \end{pmatrix} \end{aligned}$$

Note que ces matrices satisfont la condition requise :

$$\sum_{k = 0}^1 A_k^{\dagger} A_k = \vert 0\rangle\langle 0\vert 0\rangle\langle 0\vert + \vert 1\rangle\langle 1\vert 1\rangle\langle 1\vert = \vert 0\rangle\langle 0\vert + \vert 1\rangle\langle 1\vert = \mathbb{I}$$

Il convient de noter que ce choix de matrices de Kraus n'est pas unique.

Caractériser le bruit comme des canaux

Dans cette section, nous utiliserons le modèle de la sphère de Bloch et les mathématiques des canaux quantiques pour mieux comprendre différents types de bruit et d'erreurs.

Erreurs incohérentes

Revenons aux erreurs incohérentes et explorons plus précisément les erreurs de relaxation énergétique. Rappelons que l'état $|0\rangle$ est l'état fondamental d'un qubit et que l'état $|1\rangle$ a une énergie légèrement plus élevée. Parfois, les états quantiques se désexcitent (relaxent) simplement et spontanément d'un niveau d'énergie plus élevé vers un niveau plus bas. Le processus d'émission spontanée est un sujet riche et ne peut vraiment être compris sans un traitement en théorie quantique des champs. Mais l'intuition nous est à tous très familière : des perturbations aléatoires peuvent faire dévaler un rocher le long d'une colline ; elles ne feront pas remonter un rocher en haut d'une colline. La durée pendant laquelle un qubit reste dans l'état de plus haute énergie est caractérisée par un temps $T_1$. Plus précisément, la probabilité qu'un qubit préparé dans l'état $|1\rangle$ reste dans cet état après un temps $t$ est $e^{-t/T_1}$. Ou, de manière équivalente, la probabilité $p$ d'une erreur de relaxation énergétique après un temps $t$ est

$$p = 1-e^{-t/T_1}$$

Pour décrire cela avec un canal quantique dans la représentation de Kraus, nous avons besoin de matrices de Kraus qui correspondent à

• laisser les états $|0\rangle$ inchangés
• changer les états $|1\rangle$ en $|0\rangle$ avec une certaine probabilité p.

Définissons

$$\begin{aligned} A_0 & = 1|0\rangle\langle0| + \sqrt{1-p}|1\rangle\langle1|\\ & = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\\ A_1 & = \sqrt{p}|0\rangle\langle1|\\ & = \begin{pmatrix} 0 & \sqrt{p} \\ 0 & 0\end{pmatrix} \end{aligned}$$

Vérifions d'abord que cela a les effets souhaités sur une matrice de densité. Considérons un système qui est dans un état pur $|\psi\rangle = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$. Nous avons vu dans un exemple précédent que la matrice de densité pour ce cas est

$$\rho =\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}.$$

En appliquant le canal de relaxation énergétique à l'aide des matrices de Kraus, nous obtenons la nouvelle matrice de densité transformée :

$$\begin{aligned} \Phi(\rho) & = \sum_{k = 0}^{N-1} A_k \rho A_k^{\dagger}\\ & = A_0 \rho A_0^{\dagger} + A_1 \rho A_1^{\dagger}\\ & = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}\begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}+\begin{pmatrix} 0 & \sqrt{p} \\ 0 & 0\end{pmatrix}\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}\begin{pmatrix} 0 & 0 \\ \sqrt{p} & 0\end{pmatrix}\\ & = \frac{1}{2}\begin{pmatrix} 1+p & \sqrt{1-p} \\ \sqrt{1-p} & 1-p\end{pmatrix} \end{aligned}$$

Examinons cela et comparons-le à notre intuition :

Vérifions d'abord la limite lorsque $t$ tend vers zéro. Nous retrouvons notre matrice de densité initiale, comme il se doit :

$$\Phi(\rho,t \rightarrow 0) = \lim_{p\rightarrow 0}{\frac{1}{2}\begin{pmatrix} 1+p & \sqrt{1-p} \\ \sqrt{1-p} & 1-p\end{pmatrix}} = {\frac{1}{2}\begin{pmatrix} 1 & 1 \\ 1 & 1\end{pmatrix}}.$$

Au fil du temps, nous nous attendrions à ce que la probabilité de mesurer l'état $|0\rangle$ augmente, et que la probabilité de mesurer $|1\rangle$ diminue. C'est à nouveau exactement ce que nous observons, puisque

$$\begin{aligned} P_{|0\rangle} & = \langle 0 | \rho |0\rangle = \frac{1}{2}(1+p) = 1-\frac{1}{2}e^{-t/T_1}\\ P_{|1\rangle} & = \langle 1 | \rho |1\rangle = \frac{1}{2}(1-p) = \frac{1}{2}e^{-t/T_1} \end{aligned}$$

Nous pouvons aussi voir trivialement que les probabilités de mesurer $|0\rangle$ et $|1\rangle$ somment à 1, comme il se doit.

L'évolution précise des termes de cohérence (hors diagonale) dépasse le cadre de ce traitement. Mais ce qui est clair, c'est que nous disposons initialement d'une information de phase parfaite, et qu'après un temps très long, il ne peut plus y avoir d'information de phase puisque le système est entièrement relaxé vers l'état $|0\rangle$. Par conséquent, les termes de cohérence doivent tendre vers zéro aux temps très longs. En effet,

$$\lim_{p\rightarrow 1}{\sqrt{1-p}} = \lim_{t\rightarrow \infty}{\sqrt{e^{-t/T_1}}} = 0$$

Bon nombre des contraintes sur nos matrices de Kraus sont implicitement vérifiées par ces considérations intuitives. Il conviendrait de vérifier rigoureusement que les contraintes sur les canaux (et sur les matrices de Kraus en particulier) sont satisfaites, mais nous laissons cela comme exercice au lecteur.

Graphiquement, ce type de canal peut être représenté à l'aide d'une sphère de Bloch. Un état pur se situe à la surface d'une sphère de Bloch. Les états mixtes se déplacent vers l'intérieur de la sphère et s'étalent à partir d'un point unique. L'inclusion de probabilités classiques se traduit par une réduction de la distance absolue entre l'origine et l'un quelconque des états du mélange, et l'étalement d'un point unique vers une région indique le mélange de plusieurs états possibles. Dans le cas particulier d'un canal de relaxation énergétique, l'état mixte (matrice de densité) après un temps non négligeable ressemblerait à l'image ci-dessous : une région à l'intérieur de la sphère de Bloch, décalée vers le haut en direction du pôle $|0\rangle$, et contractée à la fois le long de l'axe $Z$ et dans le plan $XY$, bien que dans une moindre mesure que le long de $Z$.

Note que la région n'est pas une « calotte » de la sphère de Bloch, comme elle peut parfois apparaître dans un rendu en perspective. Comme on peut clairement le voir dans la vidéo, il s'agit d'un sphéroïde aplati, contracté et décalé vers l'état $|0\rangle$. Les canaux de bruit (et les canaux en général) s'appliquent bien sûr à des systèmes de toute taille. Mais leur représentation visuelle (comme avec une sphère de Bloch) devient difficile à mesure que le nombre d'états mutuellement orthogonaux dans l'espace de Hilbert augmente.

Vérifie ta compréhension

Vérifie que les matrices de Kraus utilisées dans le canal de relaxation énergétique ci-dessus satisfont la condition d'identité :

$$\sum_{k = 0}^{N-1} A_k^{\dagger} A_k = \mathbb{I}_{\mathsf{X}}$$

Réponse

$$\begin{aligned} \sum_{k = 0}^{N-1} A_k^{\dagger} A_k & = A_0^\dagger A_0 + A_1^\dagger A_1\\ & = \begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\begin{pmatrix} 1 & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} + \begin{pmatrix} 0 & 0 \\ \sqrt{p} & 0\end{pmatrix}\begin{pmatrix} 0 & \sqrt{p} \\ 0 & 0\end{pmatrix}\\ & = \begin{pmatrix} 1 & 0 \\ 0 & 1-p\end{pmatrix} + \begin{pmatrix} 0 & 0 \\ 0 & p\end{pmatrix}\\ & = \mathbb{I} \end{aligned}$$

Nous allons présenter deux autres types de canaux de bruit incohérent, mais nous laisserons la majeure partie de l'interprétation et de la vérification comme exercices. Le suivant est le canal de déphasage, qui décrit une perte d'information de phase, mais avec préservation des amplitudes. Bien que des probabilités à la fois classiques et de mécanique quantique puissent encore intervenir dans la probabilité de mesure globale, la perte d'information de phase est souvent décrite comme une perte d'information quantique, ou comme le système devenant plus classique.

Tout comme la relaxation énergétique a été décrite avec un temps caractéristique $T_1$, les erreurs de déphasage sont décrites par un second paramètre temporel $T_2$. La probabilité d'une erreur de déphasage après un temps $t$ est donnée par

$$p = 1-e^{-t/T_2}$$

Un ensemble de matrices de Kraus pour le canal de déphasage sur un seul qubit, en fonction de cette probabilité, est le suivant :

$$\begin{aligned} A_0 & = \sqrt{1-p}\mathbb{I}\\ & = \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\\ A_1 & = \sqrt{p}Z\\ & = \begin{pmatrix} \sqrt{p} & 0 \\ 0 & -\sqrt{p}\end{pmatrix}\\ \end{aligned}$$

Le résultat de ce canal de déphasage est visualisé à l'aide d'une sphère de Bloch dans la figure ci-dessous.

Note que les amplitudes ne sont pas modifiées, donc tout état tombant exactement sur un pôle ($|0\rangle$ ou $|1\rangle$) n'est pas affecté et reste envoyé sur la surface de la sphère dans la région ombrée. Mais l'information de phase est perdue, ce qui correspond à une contraction de la région ombrée dans le plan $XY$. Une façon de comprendre cela est la suivante : tout état quantique possible peut toujours avoir une phase bien définie, mais puisqu'il existe une probabilité classique de trouver plusieurs états avec des phases bien définies différentes, la probabilité globale d'une phase bien définie donnée est réduite.

Vérifie ta compréhension

Vérifie que les matrices de Kraus définies ci-dessus pour le canal de déphasage satisfont la condition d'identité :

$$\sum_{k = 0}^{N-1} A_k^{\dagger} A_k = \mathbb{I}_{\mathsf{X}}$$

Réponse

$$\begin{aligned} \sum_{k = 0}^{N-1} A_k^{\dagger} A_k & = A_0^\dagger A_0 + A_1^\dagger A_1\\ & = \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix}\begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} + \begin{pmatrix} \sqrt{p} & 0 \\ 0 & -\sqrt{p}\end{pmatrix}\begin{pmatrix} \sqrt{p} & \\ 0 & -\sqrt{p}\end{pmatrix}\\ & = \begin{pmatrix} 1-p & 0 \\ 0 & 1-p\end{pmatrix} + \begin{pmatrix} p & 0 \\ 0 & p\end{pmatrix}\\ & = \mathbb{I} \end{aligned}$$

Commence avec un état pur à un qubit de ton choix, avec une phase bien définie entre $|0\rangle$ et $|1\rangle$. Écris-le sous forme de matrice densité. Applique le canal de déphasage à l'aide des opérateurs de Kraus suggérés ci-dessus. Interprète la matrice densité transformée obtenue.

Réponse

Choisissons l'état $|\psi\rangle = \frac{4}{5}|0\rangle -i\frac{3}{5} |1\rangle$. La matrice densité correspondante $\rho$ est

$$\begin{aligned} \rho & = \sum_i p_i |\psi_i\rangle\langle\psi_i|\\ & = 1\left(\frac{4}{5}|0\rangle -i\frac{3}{5} |1\rangle\right) \left( \frac{4}{5}|0\langle +i\frac{3}{5} |1\langle\right)\\ & = \frac{16}{25}\begin{pmatrix} 1 & 0 \\ 0 & 0\end{pmatrix}+\frac{12i}{25}\begin{pmatrix} 0 & 1 \\ 0 & 0\end{pmatrix}-\frac{12i}{25}\begin{pmatrix} 0 & 0 \\ 1 & 0\end{pmatrix}+\frac{9}{25}\begin{pmatrix} 0 & 0 \\ 0 & 1\end{pmatrix}\\ & = \frac{1}{25}\begin{pmatrix} 16 & 12i \\ -12i & 9\end{pmatrix} \end{aligned}$$

Nous appliquons maintenant le canal de déphasage à cette matrice densité à l'aide des opérateurs de Kraus.

$$\begin{aligned} \Phi(\rho) & = \sum_{k = 0}^{N-1} A_k \rho A_k^{\dagger}\\ & = A_0 \rho A_0^\dagger + A_1 \rho A_1^\dagger\\ & = \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} \frac{1}{25}\begin{pmatrix} 16 & 12i \\ -12i & 9\end{pmatrix} \begin{pmatrix} \sqrt{1-p} & 0 \\ 0 & \sqrt{1-p}\end{pmatrix} + \begin{pmatrix} \sqrt{p} & 0 \\ 0 & -\sqrt{p}\end{pmatrix} \frac{1}{25}\begin{pmatrix} 16 & 12i \\ -12i & 9\end{pmatrix} \begin{pmatrix} \sqrt{p} & \\ 0 & -\sqrt{p}\end{pmatrix}\\ & = \frac{1}{25}\begin{pmatrix} 16(1-p) & 12i(1-p) \\ -12i(1-p) & 9(1-p)\end{pmatrix} + \frac{1}{25}\begin{pmatrix} 16p & -12ip \\ 12ip & 9p\end{pmatrix}\\ & = \frac{1}{25}\begin{pmatrix} 16 & 12i(1-2p) \\ -12i(1-2p) & 9\end{pmatrix} \end{aligned}$$

Premièrement, nous notons que la somme des éléments diagonaux est effectivement égale à un, comme il se doit. Deuxièmement, note que les éléments hors diagonale étaient initialement importants, avec une somme de 24/25, indiquant une forte cohérence. Note qu'à mesure que la probabilité d'une erreur de déphasage $p$ augmente, ces éléments hors diagonale diminuent. Cela correspond aussi à notre attente. Une subtilité : observe ce qui se passe lorsque $p\rightarrow 1$. La cohérence redevient forte ! Cela semble contre-intuitif au premier abord, car une forte probabilité d'erreur de déphasage devrait perturber notre phase, n'est-ce pas ? Le piège est que si nous sommes sûrs à 100 % qu'une erreur de phase se produit, alors nous disposons à nouveau d'une information solide sur la phase ; la phase s'est simplement inversée. Avec cette observation, nous pourrions nous attendre à ce que la pire information de phase corresponde à une probabilité de 50 % qu'une erreur de phase se produise, et c'est effectivement ce que nous constatons.

Notre dernier exemple de canal de bruit décrivant des erreurs incohérentes est le canal de bruit de Pauli. Ce canal décrit l'occurrence de trois types d'erreurs avec des probabilités indépendantes :

• Erreur de bascule de bit (erreur X) avec probabilité $p_x$
• Erreur de bascule de phase (erreur Z) avec probabilité $p_z$
• Combinaison de X et Z (erreur Y) avec probabilité $p_y$ Ici, $0\leq p_j \leq 1$ pour tout $j$. Un corollaire est que la probabilité qu'aucune erreur ne se produise est $p_I = 1-p_x-p_y-p_z$.

Les opérateurs de Kraus pour ce canal sont :

$$\begin{aligned} A_0 & = \sqrt{p_I}I\\ A_1 & = \sqrt{p_X}X\\ A_2 & = \sqrt{p_Y}Y\\ A_3 & = \sqrt{p_Z}Z \end{aligned}$$

Dans le cas du canal de bruit de Pauli, il est instructif d'écrire le canal lui-même :

$$\Phi(\rho) = p_I I\rho I + p_X X\rho X+p_Y Y \rho Y + p_Z Z \rho Z$$

Nous voyons à partir de cette forme que le canal de bruit de Pauli implémente une ou plusieurs erreurs correspondant à l'action des matrices de Pauli $P_j$, chacune avec une probabilité $p_j$.

Différentes combinaisons de probabilités de bascule produiront différentes visualisations. Nous visualisons ici le cas particulier où $p_X = p_Y = p_Z$, également appelé canal dépolarisant.

Modéliser les erreurs cohérentes

Les canaux quantiques peuvent représenter à la fois des erreurs cohérentes et incohérentes, mais en pratique, ils sont principalement utilisés pour les erreurs incohérentes, car les erreurs cohérentes sont mieux modélisées comme des erreurs de calibration unitaires ou converties en canaux stochastiques pour faciliter l'analyse. Dans cette section, nous allons présenter des approches plus adaptées aux erreurs cohérentes.

Les erreurs cohérentes peuvent être modélisées par des portes unitaires indésirables. Quelques exemples simples incluent des rotations mal alignées ou une sous-/sur-rotation. Dans l'image ci-dessous, nous montrons une rotation mal alignée comme une rotation $Y$ supplémentaire d'une petite quantité $\epsilon$ en plus de la rotation souhaitée autour de l'axe $X$. Une sur-rotation est décrite par la rotation $X$ souhaitée ainsi qu'une rotation supplémentaire autour du même axe $X_\epsilon$.

Erreurs à deux qubits et cônes de lumière ombrés

Une porte à un qubit fait tourner un qubit isolé. Une porte à deux qubits implémente une logique reposant sur deux qubits, mais ne peut effectuer de mesure directe d'aucun des deux qubits ; elle doit donc activer une interaction entre les qubits. Cette interaction est la raison pour laquelle nous pouvons construire de l'intrication, et c'est aussi d'où proviennent une grande partie du bruit, de la diaphonie et des difficultés de calibration. Cette interaction entre qubits permet également aux erreurs de se propager. Si un qubit présente une erreur, et qu'il sert de qubit de contrôle pour un autre qubit cible, l'erreur peut être transmise au qubit cible. Dans cette leçon, nous allons examiner ce que les portes à deux qubits signifient pour les taux d'erreur et leur propagation au sein d'un circuit.

Portes à résonance croisée avec écho

Différentes architectures matérielles et familles de portes conçoivent cette interaction de différentes manières. Les ordinateurs quantiques IBM implémentent des portes abstraites à deux qubits comme les portes CZ ou CX à l'aide de portes à résonance croisée avec écho (ECR) natives du matériel. Les portes ECR génèrent une interaction effective $ZX$ à l'aide d'un pilotage micro-ondes. Des portes apparentées comme CNOT sont construites à partir de $ZX$ en ajoutant des rotations à un qubit.

Différents qubits ont différentes fréquences de résonance (fréquences auxquelles ils réagissent fortement). Une opération standard peut utiliser cette fréquence de résonance pour induire une transition dans un qubit. Mais que se passe-t-il si tu pilotes le qubit C à la fréquence de résonance d'un qubit adjacent T ? Les qubits adjacents sont liés par une interaction capacitive fixe ou médiée par un résonateur. En raison de ce couplage, un pilotage sur le qubit C « fuit » dans l'hamiltonien du qubit T. La force et la direction de ce pilotage effectif dépendent de l'état du qubit C ($|0\rangle$ ou $|1\rangle$). Ici, le qubit C est le contrôle et le qubit T est la cible.

Le résultat est une rotation effective du qubit cible conditionnée par l'état du qubit de contrôle. Mathématiquement :

$$H_{eff} \approx \Omega Z_C X_T +\text{autres termes}$$

Cette interaction ZX est exactement ce dont tu as besoin pour construire un CNOT. Mais les autres termes peuvent inclure certaines erreurs, et incluent presque certainement un couplage capacitif entre les qubits C et T, qui correspond à un terme ZZ.

$$H_\mathrm{CR} = \underbrace{\Omega \, Z_C X_T}_{\text{desired}} + \underbrace{\alpha\, I_C X_T + \beta\, Z_C I_T + \gamma\, I_C Z_T + \delta\, Z_C Z_T + \dots}_{\text{undesired}}.$$

Nous pouvons penser à ces termes supplémentaires de la manière suivante :

• IX = la cible est pilotée involontairement

• ZI = le qubit de contrôle acquiert une rotation Z indésirable

• IZ = le qubit cible acquiert une rotation Z indésirable

• ZZ = décalage de phase statique dépendant de l'état

• autres = petites interactions XY, XX, d'ordre supérieur

Une porte ECR est simplement une rotation contrôlée plus une impulsion d'écho soigneusement choisie sur le qubit de contrôle. L'écho inverse le signe de nombreux termes indésirables tout en préservant l'interaction ZX. Ce processus annule plutôt bien les erreurs IX et ZI, et parfois certains termes d'ordre supérieur. Mais l'écho ne peut pas annuler le couplage ZZ statique car il commute avec l'impulsion d'écho. Il existe d'autres interactions qui ne s'annuleront pas dans ce processus : certaines non-linéarités résiduelles et effets de qubits spectateurs, des fuites et une contamination de pilotage à longue portée, ainsi que quelques autres — mais le terme ZZ est particulièrement important.

Ce processus nécessite souvent des temps de pilotage supérieurs d'un ordre de grandeur à ceux des portes à un qubit. La combinaison de temps de pilotage plus longs, de termes ZZ persistants dans l'hamiltonien, et d'imperfections de couplage fait des portes à deux qubits la source dominante d'erreurs de porte. Note aussi que si l'on a besoin d'interactions dans un circuit entre des qubits qui ne sont pas adjacents, les portes SWAP nécessaires sont elles aussi évidemment des portes à deux qubits. C'est pourquoi la métrique standard liée à la profondeur est : la profondeur transpilée à deux qubits. Nous nous soucions principalement des portes à deux qubits car elles dominent l'erreur de porte, et nous devons examiner les circuits transpilés car la transpilation introduit souvent de nombreuses portes à deux qubits supplémentaires sous forme de portes SWAP.

Vérifie ta compréhension

Explique pourquoi nous nous soucions principalement de la profondeur transpilée à deux qubits. Assure-toi de prendre en compte les contraintes matérielles, ainsi que le fait que la profondeur des portes à un qubit peut être bien plus grande.

Réponse

Les portes à deux qubits ont des taux d'erreur bien plus élevés que les portes à un qubit. Les portes à un qubit ne sont pas parfaites, il peut donc y avoir des cas où il est également utile de considérer la profondeur à un qubit. Mais la profondeur des portes à deux qubits tend à dominer le comportement d'erreur d'un circuit. Nous devons considérer le circuit transpilé. Les ordinateurs quantiques modernes n'ont pas de connectivité totale entre tous les qubits. Les ordinateurs quantiques IBM utilisent soit une grille carrée, soit une grille en « heavy hex », ce qui signifie que les qubits ont 2, 3 ou 4 voisins les plus proches auxquels ils peuvent être directement couplés à l'aide d'une seule porte à deux qubits. Toute intrication avec d'autres qubits non adjacents nécessite de déplacer l'information sur l'ordinateur quantique à l'aide de portes SWAP à deux qubits. Ainsi, la transpilation tend à augmenter la profondeur des portes à deux qubits. Pour des circuits fortement intriqués, cette augmentation peut être très importante.

Cônes de lumière ombrés

Supposons qu'un seul qubit soit bien isolé de tous les autres. Une erreur sur ce qubit ne causera aucune erreur sur les autres qubits. Mais lorsqu'un qubit interagit avec un autre, les erreurs peuvent se propager. La façon dont les erreurs se propagent dépend de la façon dont les qubits interagissent. Considère le circuit ci-dessous. Suppose que tous les qubits adjacents dans le diagramme du circuit sont également adjacents sur la puce quantique (c'est-à-dire que l'information n'aura pas besoin d'être déplacée vers d'autres qubits pour faciliter les interactions décrites).

Bien que tu n'aies peut-être pas pensé à cela de cette façon, il s'agit d'une sorte de diagramme d'espace-temps. L'axe vertical d'un circuit quantique représente différents qubits disposés dans l'espace. L'axe horizontal représente le temps sur lequel une séquence de portes est appliquée. En empruntant le langage de la relativité, un cône de lumière représente la région de l'espace-temps qui est accessible depuis un point via des interactions causales.

Dans la figure ci-dessus, le type d'erreur n'a pas été précisé. Il s'avère que le type d'erreur affecte le cône de lumière, car certaines erreurs affectent la logique d'une porte à deux qubits, et d'autres non. Nous y reviendrons sous peu. Pour l'instant, considère que les lignes jaunes sont des chemins de propagation potentielle d'un certain type d'erreur. Observe, par exemple dans la partie (a) de la figure, qu'une erreur à un qubit sur la porte RZ du qubit 4 ne peut se propager qu'en avant dans le temps sur ce seul qubit. Elle ne peut pas se propager à d'autres qubits, car le qubit 4 n'est intriqué avec aucun autre qubit. C'est le bon moment pour noter que le qubit 4 est assez inutile dans ce circuit, et en effet, l'ensemble du circuit est construit uniquement à des fins pédagogiques.

Une erreur sur la porte Z du qubit 0 (pas nécessairement une erreur Z, simplement une erreur quelconque à cet endroit), cependant, pourrait se propager à un autre qubit : le qubit 1, via le CNOT final qui utilise le qubit 0 comme contrôle et le qubit 1 comme cible. Ceci est montré dans la partie (b). Comme on pourrait s'y attendre, une erreur plus tôt dans le circuit aura souvent une chance de se propager à travers davantage de qubits. La partie (c) montre qu'une erreur dans la préparation initiale de l'état du qubit 0 peut se propager à tous les qubits sauf le qubit 4, qui est isolé.

Cette configuration montre comment une erreur peut se propager en avant dans le temps pour affecter les mesures. Mais tu peux aussi examiner la question inverse : pour une mesure spécifique à un qubit, quelles parties de mon circuit auraient pu y contribuer une erreur ? Dans ce cas, tu commencerais simplement par la mesure ou un autre point d'intérêt et remonterais (dans le temps) à travers le circuit, en suivant tous les circuits intriquants comme le montre la partie (d). Sont également indiqués quelques points choisis aléatoirement où des erreurs pourraient se produire.

Dans la figure ci-dessus, les erreurs se propagent entre les qubits via des portes ECR, mais une discussion similaire pourrait s'appliquer à d'autres portes à deux qubits. Ces portes ont un contrôle et une cible. Il est clair qu'une erreur sur le contrôle peut affecter la logique de la porte et peut ainsi entraîner une erreur sur la cible. Mais qu'en est-il de l'autre direction ? Une erreur sur la cible peut-elle se propager au qubit de contrôle ? Rappelle-toi que le couplage entre contrôle et cible pour les portes ECR n'est pas purement de type ZX idéal ; il comporte aussi un couplage ZZ indésirable.

Si une erreur sur la cible commute avec le couplage ZZ, alors elle ne peut pas se propager au qubit de contrôle. Nous pouvons le voir à travers les mécanismes physiques en jeu. Une façon rapide de le voir est que si une erreur $E$ commute avec $ZZ$, alors leur ordre peut être échangé sans affecter le résultat. Cependant, si le fait que $E$ se produise juste avant le couplage $ZZ$ revient au même que si elle agissait après le couplage $ZZ$, alors elle ne peut pas affecter le contrôle, puisque dans ce dernier cas, l'erreur devrait remonter le temps. Si une erreur ne commute pas avec le couplage ZZ, alors elle pourrait effectivement se propager de la cible vers le contrôle. Ainsi, dans le cas d'une porte ECR, les erreurs Z ne pourraient pas se propager de la cible vers le contrôle, mais les erreurs X ou Y le pourraient.

Vérifie ta compréhension

Dans la partie (d) de la figure ci-dessus, regarde les lignes verticales entre les qubits 0 et 1. Est-il correct que certaines erreurs pourraient se propager à travers ces lignes ? Encore une fois, cela peut dépendre du type d'erreur, et nous n'en avons pas encore discuté. La question est de savoir s'il existe une erreur qui pourrait se propager comme le montrent ces lignes verticales. Explique.

Réponse

Oui, elles sont correctes. En traçant le cône de lumière en remontant depuis la mesure, on peut avoir l'impression d'affirmer que quelque chose se déplace de la cible vers le contrôle. Cependant, la signification du diagramme est en fait qu'une erreur aurait pu se déplacer du contrôle (qubit 0) vers la cible (qubit 1) pour causer une erreur au point d'intérêt. Si ton intuition est que cela dépend du type d'erreur, tu as tout à fait raison. Ceci est partiellement abordé dans la section suivante.

En partant d'une version sans erreur des circuits du diagramme ci-dessus, trace la propagation potentielle d'une erreur dans la première porte de Hadamard agissant sur le qubit 2. Liste tous les qubits qui pourraient être affectés à la fin du circuit si l'erreur est (a) une bascule de phase, et (b) une bascule de bit. Indice : pense à la façon dont l'information sur chaque qubit est utilisée.

Réponse

(a) Le qubit 3 pourrait être affecté, ainsi qu'évidemment le qubit 2 lui-même. Aucun autre ! Si tu as listé les qubits 0 et 1, note que le qubit 2 est la cible de l'ECR l'intriquant avec le qubit 1. Aucun changement n'est apporté au qubit 1 dans cette porte. (b) Les qubits 0 à 3 pourraient être affectés. L'erreur de bascule de bit ou de type X ne commute pas avec le couplage ZZ dans la porte ECR et peut donc se propager de la cible vers le contrôle.

Propagation d'erreur

Dans la section précédente, nous avons discuté de la propagation d'erreur sans lui donner de définition formelle. Désormais :

Pour une erreur $E$ qui se produit avant une partie du contenu logique d'un circuit $U$, la propagation d'erreur consiste à trouver l'opérateur équivalent $E'$ qui reproduit le même résultat erroné lorsqu'il est appliqué après $U$ plutôt qu'avant.

$$\boxed{ \text{An error } E \text{ propagates through a unitary } U \text{ as } E' = U E U^\dagger }$$ $$\boxed{ U\,E\,|\psi\rangle = E'\,U\,|\psi\rangle }$$

L'image de la propagation d'erreur dans la section précédente suggérait que les erreurs pouvaient se propager d'un qubit de contrôle à un qubit cible à travers une porte CNOT. Une façon de vérifier quand cela est vrai est de considérer une erreur sur le contrôle ou sur la cible avant l'intrication, et de vérifier si cet opérateur commute avec la porte CNOT. Si les deux opérateurs commutent, alors il n'y a pas de différence si tu les appliques dans l'ordre inverse, ce qui signifie que l'erreur pourrait simplement être « déplacée au-delà » du CNOT sans avoir aucun effet sur les autres qubits. C'est la façon la plus courante d'aborder la propagation d'erreur, et elle donne les règles suivantes :

Soit le qubit 0 le contrôle et le qubit 1 la cible. Considère les erreurs X et Z sur les qubits de contrôle et cible ($X_c$, $Z_c$, $X_t$, et $Z_t$, respectivement). Déplacer ces erreurs au-delà d'un $\text{CNOT}_{0\to1}$ fait que les erreurs deviennent :

$$\begin{aligned} X_c &\to X_c X_t\\ Z_c &\to Z_c\\ X_t &\to X_t\\ Z_t &\to Z_c Z_t \end{aligned}$$

Nous énonçons ce qui précède sans preuve. Mais si tu es comme l'auteur de cette leçon et préfères la représentation de Schr"odinger, tu peux aussi écrire des états de contrôle et cible arbitraires, appliquer l'erreur, puis le CNOT, et examiner l'état final. Si tu compares cet état final à un cas sans erreur, tu peux voir quelle combinaison d'erreurs appliquée après le CNOT donnerait l'état erroné, et en particulier, tu peux voir si l'opération d'erreur s'est propagée d'un qubit à l'autre.

Contrôle initial	Cible initiale	Erreur	Final	Équiv. d'erreur post-CNOT
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	Aucune	$\alpha\gamma \vert 00\rangle+\alpha\delta \vert 10\rangle + \beta\gamma \vert 11\rangle +\beta\delta \vert 01\rangle$	Non applicable
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	X sur le contrôle	$\alpha\gamma \vert 11\rangle+\alpha\delta \vert 01\rangle + \beta\gamma \vert 10\rangle +\beta\delta \vert 00\rangle$	$X_c X_t$
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	Z sur le contrôle	$\alpha\gamma \vert 00\rangle+\alpha\delta \vert 10\rangle - \beta\gamma \vert 11\rangle -\beta\delta \vert 01\rangle$	$Z_c$
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	X sur la cible	$\alpha\gamma \vert 10\rangle+\alpha\delta \vert 00\rangle + \beta\gamma \vert 01\rangle +\beta\delta \vert 11\rangle$	$X_t$
$\alpha\vert 0\rangle+\beta \vert 1\rangle$	$\gamma \vert 0\rangle+\delta \vert 1\rangle$	Z sur la cible	$\alpha\gamma \vert 00\rangle-\alpha\delta \vert 10\rangle + \beta\gamma \vert 11\rangle -\beta\delta \vert 01\rangle$	$Z_c Z_t$

Peut-être étonnamment, une erreur Z sur la cible provoque bien la propagation d'une erreur en retour vers le contrôle !

Comme tu peux l'imaginer, suivre une telle propagation d'opérateurs d'erreur en avant à travers les circuits (ou de manière équivalente, propager en arrière les opérateurs à mesurer) est compliqué. Qiskit dispose d'outils pour faciliter cela, que nous découvrirons dans la leçon 6 sur les flux de travail modernes.

Il existe un addon Qiskit appelé Shaded Lightcones. L'addon shaded lightcones (SLC) analyse la propagation d'erreurs dans les circuits quantiques en utilisant la propagation de Pauli pour identifier quelles parties d'un circuit peuvent réellement influencer un observable cible. Il est conçu principalement pour rendre l'atténuation d'erreurs plus efficace, en particulier pour les flux de travail d'annulation d'erreur probabiliste (PEC). Nous n'explorerons que brièvement cet outil ici, et en ferons un usage plus large dans le contexte des techniques d'atténuation d'erreurs dans les leçons futures. Il utilise la propagation d'opérateurs de Pauli pour cartographier la propagation d'erreurs de différents types, produisant un cône de lumière pour les erreurs de type X, Y et Z.

Les cônes de lumière ombrés (SLC) vont plus loin, en utilisant des simulations classiques pour borner plus étroitement la sensibilité aux erreurs tout au long du circuit. Cela échange du temps QPU contre du temps CPU et réduit le surcoût d'échantillonnage nécessaire pour renormaliser le biais. Au lieu d'une coupure stricte, chaque erreur potentielle dans le circuit se voit attribuer une « ombre » graduée qui borne supérieurement la sensibilité de l'observable à cette erreur. Cette caractérisation affinée permet des applications plus efficaces et ciblées de la PEC avec une variance réduite, tout en donnant à l'utilisateur la possibilité d'ajuster de manière contrôlée le biais dans l'estimation de l'observable. Voir Lightcone shading for classically accelerated quantum error mitigation pour plus de détails.

Nous ne présenterons pas de workflow complet ici. Nous montrons simplement, de manière schématique, comment ce workflow traite un circuit :

Le workflow sépare le circuit en « boîtes » utiles pour apprendre le comportement du bruit :

Enfin, il utilise la propagation d'opérateurs et l'apprentissage du bruit pour produire une carte ombrée de la sensibilité aux erreurs tout au long du circuit :

Chaque boîte colorée dans le résultat correspond à un qubit spécifique à un instant précis. Les boîtes les plus sombres (violettes) indiquent un qubit et une couche pour lesquels une erreur ne peut pas se propager jusqu'à la ou les mesures d'intérêt. Les boîtes les plus claires (jaunes) correspondent à un qubit et une couche pour lesquels une erreur peut avoir une forte influence sur la ou les mesures d'intérêt.

Remarquez les régions violettes à droite de chaque carte. Une erreur survenant à la même couche que la mesure, mais sur un qubit différent, ne peut pas affecter la mesure compte tenu de la connectivité du circuit illustrée. De même, une erreur survenant une couche plus tôt (une couche vers la gauche) ne peut se propager qu'au qubit adjacent à l'étape suivante, en raison de la structure de la couche d'intrication, et ainsi de suite. La forme conique à droite est donc générale dès lors que relativement peu de qubits sont impliqués dans la mesure d'intérêt.

Vérifie ta compréhension

Penses-tu qu'il est préférable de créer une carte de cône de lumière ombré avant ou après la transpilation ? Pourquoi ?

Réponse

Cela doit être fait après la transpilation. Pour que ces différentes cartes soient utiles, nous devons nous assurer que les qubits adjacents de notre circuit correspondent à des qubits adjacents sur notre puce quantique. Sinon, les portes intriquantes représentées comme agissant sur des qubits adjacents dans le diagramme de circuit finiraient par nécessiter des portes SWAP et une structure de circuit plus compliquée.