Codes de surface & Calcul tolérant aux fautes (FTQC)

Codes de surface — le « RAID » des qubits

Un qubit physique est bruité : il perd son information en quelques microsecondes. La parade : ne jamais confier l’information à un seul qubit, mais la diluer dans tout un réseau. C’est l’idée du RAID pour les disques durs, transposée au quantique.

Analogie. Sur un serveur, RAID répartit un fichier sur plusieurs disques + des bits de parité : si un disque lâche, on reconstruit. Ici on répartit un qubit logique sur des dizaines de qubits physiques arrangés sur une grille 2D.

Deux familles de qubits sur la grille

• Qubits de données : portent (collectivement) l’état logique.
• Qubits de mesure (ancillas) : servent à lire des parités de voisins — les stabilisateurs (de type X et de type Z).

On ne mesure jamais les qubits de données directement (cela effondrerait l’état). On mesure en boucle les stabilisateurs : chaque résultat est un syndrome. Un syndrome qui change signale une erreur, comme un voyant qui s’allume. Un décodeur classique (souvent un couplage de poids minimum, MWPM) regarde la carte des syndromes et en déduit la correction la plus probable.

Le tour de magie. Mesurer une parité (« ces qubits sont-ils d’accord ? ») ne révèle rien sur la valeur logique encodée — seulement sur les erreurs. L’information logique survit.

Distance, coût, seuil

C’est pourquoi le code de surface est le candidat n°1 du matériel supraconducteur : il ne demande que des interactions entre voisins sur une grille 2D et tolère un taux d’erreur relativement élevé (~1 %).

# Qiskit — mesure de syndrome (parité Z) de 2 qubits de données via une ancilla
from qiskit import QuantumCircuit
qc = QuantumCircuit(3, 1)   # q0, q1 = données ; q2 = ancilla de syndrome
qc.cx(0, 2)                 # accumule la parité de q0...
qc.cx(1, 2)                 # ...puis de q1 sur l'ancilla
qc.measure(2, 0)            # 0 = parité paire (OK), 1 = erreur détectée
# Les qubits de données ne sont JAMAIS mesurés : la superposition logique survit.

# Qiskit — mesurer la parité Z⊗Z sans détruire les données
from qiskit import QuantumCircuit

def mesurer_syndrome_zz() -> QuantumCircuit:
    qc = QuantumCircuit(3, 1)   # q0, q1 = données ; q2 = ancilla
    qc.cx(0, 2)                 # parité de q0...
    qc.cx(1, 2)                 # ...puis de q1, accumulée sur l'ancilla
    qc.measure(2, 0)            # 0 = parité paire (OK), 1 = erreur
    return qc
    # Les qubits de données ne sont JAMAIS mesurés : la superposition logique survit.

⚠️ Ce n’est pas du clonage. On ne copie aucun qubit (le non-clonage l’interdit) : on intrique les données avec des ancillas et on ne lit que des parités. Le syndrome ne révèle pas l’état logique — uniquement les erreurs.

Calcul tolérant aux fautes (FTQC)

Corriger les erreurs, c’est bien. Mais les portes elles-mêmes sont bruitées, et même le circuit qui mesure les syndromes peut faillir. Si une seule faute se propage à tout un bloc, la correction devient impossible. Le calcul tolérant aux fautes conçoit chaque étape pour qu’une faute physique isolée ne puisse jamais ruiner un qubit logique.

Les portes transversales : la brique sûre

Analogie. Imagine deux rangées de soldats. Le soldat i de la rangée A ne parle qu’au soldat i de la rangée B. Si l’un se trompe, son erreur ne contamine pas toute la rangée.

Une porte transversale s’applique bit à bit sur les qubits physiques d’un bloc : un composant physique par qubit. Une faille reste donc confinée à un seul qubit par bloc — pas de propagation. Ce sont les portes « bon marché et sûres ».

# Qiskit — CNOT transversal entre deux blocs encodés (bit à bit)
from qiskit import QuantumCircuit

def cnot_transversal(n: int) -> QuantumCircuit:
    """Applique un CNOT bit à bit entre un bloc ctrl et un bloc cible."""
    qc = QuantumCircuit(2 * n)          # [0..n-1] = ctrl, [n..2n-1] = cible
    for i in range(n):
        qc.cx(i, n + i)                 # un CNOT physique par paire alignée
    return qc
    # Une faute sur un CNOT n'affecte qu'UN qubit dans chaque bloc.

Le hic : Eastin–Knill

Théorème d’Eastin–Knill. Aucun code ne possède un jeu universel de portes transversales. Il manque toujours au moins une porte — en pratique la porte T.

# Qiskit — Clifford vs non-Clifford
from qiskit import QuantumCircuit
qc = QuantumCircuit(1)
qc.h(0); qc.s(0)   # Clifford -> souvent transversales (sûres, bon marché)
qc.t(0)            # T : non-Clifford -> nécessite la distillation d'états magiques

Distillation d’états magiques

Pour réaliser la porte T malgré tout : on prépare beaucoup d’« états magiques » bruités, on en distille quelques-uns de haute qualité, puis on les injecte par téléportation de porte. C’est le poste de coût dominant de la FTQC.

Ordre de grandeur. Le rapport qubits physiques / qubit logique peut dépasser 1000:1. Casser RSA-2048 réclame ainsi des millions de qubits physiques pour seulement quelques milliers de qubits logiques.

⚠️ La correction d’erreur seule ne suffit pas. Sans portes tolérantes aux fautes (transversales + distillation), une faute dans le circuit de correction se propage. Et l’universalité « tout transversal » est interdite (Eastin–Knill) : la porte T se paie cash.