Calcul tolérant aux fautes (FTQC) & Architectures matérielles

Calcul tolérant aux fautes (FTQC)

L’idée centrale

Un calcul est tolérant aux fautes quand les erreurs qui surviennent pendant le calcul ne se propagent pas de manière incontrôlée — chaque opération logique peut introduire au plus une erreur dans chaque bloc de code correcteur.

L’objectif : tant que le taux d’erreur physique reste en dessous d’un seuil (~0,1 % à 1 % selon le code), on peut calculer arbitrairement longtemps en ajoutant des qubits physiques.

Analogie : Imaginez une usine où chaque machine tombe en panne de temps en temps. La tolérance aux fautes, c’est organiser la chaîne de production de façon à ce qu’une panne isolée ne contamine jamais le produit final — grâce à des contrôles qualité (mesures de syndrome) entre chaque étape.

Portes transversales

Une porte est transversale quand elle agit qubit physique par qubit physique, sans interaction entre les qubits d’un même bloc logique. Avantage : une erreur sur un qubit physique ne peut pas se propager aux autres qubits du même bloc.

• Les portes Pauli (X, Z) et CNOT sont naturellement transversales pour de nombreux codes stabilisateurs.
• Les portes T et Toffoli ne le sont généralement pas.

Théorème d’Eastin–Knill

⚠️ Théorème d’Eastin–Knill : Aucun code correcteur d’erreur ne peut implémenter toutes les portes d’un ensemble universel de manière transversale. Il faudra toujours au moins une porte « non transversale » — d’où la nécessité de la distillation d’états magiques.

En d’autres termes : on ne peut pas avoir le beurre et l’argent du beurre. Un code qui corrige parfaitement les erreurs ne peut pas exécuter n’importe quelle porte « gratuitement ». Pour compléter l’ensemble universel, on utilise la distillation d’états magiques.

Distillation d’états magiques (Magic State Distillation)

Pour exécuter une porte T (nécessaire à l’universalité), on prépare des états spéciaux appelés états magiques (|T⟩ = T|+⟩). Comme ces états sont bruités, on en combine plusieurs pour en « distiller » un seul de haute fidélité.

Le surcoût est énorme : une seule porte T logique peut nécessiter des milliers de qubits physiques et des dizaines de cycles de distillation. C’est le principal goulot d’étranglement du FTQC.

# Estimation simplifiée du surcoût FTQC avec Qiskit
from qiskit.circuit import QuantumCircuit

# Circuit logique simple : H + T + mesure
qc = QuantumCircuit(1, 1)
qc.h(0)
qc.t(0)      # ← Cette seule porte T coûte ~1000-15000 qubits physiques en FTQC
qc.measure(0, 0)

# Compter les portes T pour estimer le coût
t_count = qc.count_ops().get('t', 0)
print(f"Nombre de portes T : {t_count}")
print(f"Surcoût estimé : {t_count * 1000} à {t_count * 15000} qubits physiques")

Surcoût en qubits physiques

Architectures matérielles

L’idée centrale

Il n’existe pas un seul type de qubit : chaque technologie encode l’information quantique différemment, avec des compromis entre cohérence, connectivité, fidélité des portes et passage à l’échelle.

Les principales plateformes

Le triangle des compromis

Chaque architecture navigue dans un triangle :

1. Cohérence — combien de temps un qubit garde son état (T₁, T₂). Les ions piégés excellent ici (secondes à minutes).
2. Connectivité — quels qubits peuvent interagir directement. Les ions piégés ont une connectivité all-to-all ; les supraconducteurs sont limités aux voisins proches.
3. Fidélité des portes — le taux d’erreur par opération. Quantinuum atteint >99,9% sur 2 qubits, IBM Eagle ~99,5%.

⚠️ Piège courant : Comparer les architectures uniquement sur le nombre de qubits est trompeur. 1 000 qubits supraconducteurs bruités ≠ 32 ions piégés haute fidélité. La métrique pertinente est le circuit depth utile — le nombre de portes enchaînables avant que le bruit domine.

Lien FTQC ↔ Architecture

Le choix d’architecture dicte le code correcteur optimal :

• Les codes de surface (grille 2D, voisins proches) sont idéaux pour les supraconducteurs. Seuil ~1 % — atteignable avec les meilleurs transmons.
• Les ions piégés, avec leur connectivité all-to-all, peuvent utiliser des codes plus compacts (codes de couleur, codes LDPC quantiques) nécessitant moins de qubits physiques par qubit logique.

# Simuler le bruit d'un transmon avec Qiskit Aer
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, depolarizing_error
from qiskit import QuantumCircuit, transpile

# Modèle de bruit simplifié pour un processeur supraconducteur
noise_model = NoiseModel()
# Erreur 1-qubit : ~0.1% (fidélité 99.9%)
noise_model.add_all_qubit_quantum_error(
    depolarizing_error(0.001, 1), ['h', 'x', 'z', 't', 's'])
# Erreur 2-qubits : ~0.5% (fidélité 99.5%)
noise_model.add_all_qubit_quantum_error(
    depolarizing_error(0.005, 2), ['cx'])

# Circuit test : état de Bell
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])

# Exécuter avec bruit
sim = AerSimulator(noise_model=noise_model)
result = sim.run(transpile(qc, sim), shots=10000).result()
counts = result.get_counts()
print(f"Résultats avec bruit supraconducteur : {counts}")
# Attendu : ~49.5% |00⟩, ~49.5% |11⟩, quelques % d'erreurs |01⟩/|10⟩