Calcul tolérant aux fautes (FTQC) & Suprématie/avantage quantique

Calcul tolérant aux fautes (FTQC)

Corriger ne suffit pas — il faut corriger sans casser

En jours 28-31, on a vu comment encoder un qubit logique dans plusieurs qubits physiques et détecter des erreurs via les syndromes. Mais il y a un problème sournois : les opérations que tu effectues sur les qubits — y compris les opérations de correction elles-mêmes — peuvent introduire de nouvelles erreurs. Si une seule porte défaillante dans le circuit de correction propage son erreur à plusieurs qubits du même bloc logique, tu te retrouves avec plus d’erreurs qu’au départ.

Analogie : Imagine un chirurgien qui opère pour retirer une tumeur, mais dont le scalpel n’est pas stérilisé. L’opération corrige le problème initial, mais introduit une infection qui se propage. La tolérance aux fautes, c’est l’équivalent de la stérilisation : chaque étape du processus de correction est conçue pour que même si elle est imparfaite, elle ne propage pas les erreurs au-delà de ce que le code peut gérer.

Définition formelle : Un circuit est tolérant aux fautes si une seule erreur physique (dans n’importe quelle porte ou mesure du circuit) ne peut jamais produire plus d’une erreur par bloc logique. Tant que le code peut corriger au moins une erreur, le circuit tolérant aux fautes garantit que la correction fonctionne.

Portes transversales — chaque qubit travaille indépendamment

La technique la plus naturelle pour rester tolérant aux fautes est d’utiliser des portes transversales. Le principe est simple : pour appliquer une porte logique sur un qubit logique encodé dans n qubits physiques, on applique la même porte physique individuellement sur chaque qubit du bloc, sans jamais faire interagir deux qubits du même bloc entre eux.

Analogie C# : C’est comme un Parallel.ForEach sans état partagé. Chaque thread (qubit physique) exécute la même opération de manière totalement isolée. Si un thread plante, aucun autre n’est affecté. C’est l’opposé d’un lock partagé où un crash corrompt tout le monde. Les portes transversales, c’est la programmation sans effet de bord appliquée à la correction d’erreur.

Concrètement, dans le code de Steane [[7, 1, 3]] :

• La porte X logique = appliquer X sur chacun des 7 qubits physiques
• La porte Z logique = appliquer Z sur chacun des 7 qubits physiques
• La porte H logique = appliquer H sur chacun des 7 qubits physiques
• La porte CNOT logique = appliquer CNOT entre les qubits correspondants des deux blocs (qubit 1 du bloc A contrôle qubit 1 du bloc B, qubit 2 contrôle qubit 2, etc.)

Si une porte physique H est défaillante sur le qubit 3, seul le qubit 3 est affecté. L’erreur reste confinée à un seul qubit par bloc — exactement ce dont le code a besoin pour la corriger.

Le théorème d’Eastin–Knill — le grain de sable

Voici le problème : il est impossible qu’un code de correction d’erreur possède un ensemble universel de portes transversales. C’est le théorème d’Eastin–Knill (2009).

Analogie : Imagine un système de types dans un langage de programmation. Tu voudrais un type qui soit à la fois sérialisable, thread-safe, et qui supporte l’héritage multiple avec résolution automatique des conflits. Mathématiquement, c’est impossible — il y a des contraintes mutuellement exclusives. De la même façon, les contraintes de symétrie imposées par la transversalité sont incompatibles avec l’universalité du jeu de portes.

Pour le code de Steane, les portes H, X, Z, CNOT et S sont transversales — mais la porte T ne l’est pas. Or, sans la porte T, on ne peut pas faire de calcul universel. La porte T est le « grain de sable » qui empêche tout d’être simple.

En résumé : pour tout code QEC, il existera au moins une porte (souvent T) qui nécessite une méthode spéciale et coûteuse pour être appliquée de manière tolérante aux fautes.

Distillation d’états magiques — fabriquer du T propre à partir de T sale

La solution au problème d’Eastin–Knill est la distillation d’états magiques (magic state distillation). L’idée en trois étapes :

Étape 1 — Préparer des états « magiques » bruités : On prépare l’état spécial |T⟩ = (|0⟩ + e^(iπ/4)|1⟩) / √2 — appelé état magique parce qu’il « contient » la porte T. Ces préparations sont imparfaites et produisent des états bruités.

Étape 2 — Distiller (purifier) : On prend plusieurs copies bruitées de |T⟩ (typiquement 15), on les fait passer à travers un circuit de distillation qui consomme ces copies et produit une seule copie de bien meilleure fidélité. On peut itérer le processus pour atteindre une précision arbitraire.

Étape 3 — Téléporter la porte T : On utilise la téléportation de porte (gate teleportation) : au lieu d’appliquer directement T au qubit logique, on consomme l’état |T⟩ purifié et on effectue une mesure + correction classiquement contrôlée. Le résultat est une porte T appliquée de manière tolérante aux fautes.

Analogie : C’est comme la purification de l’eau. Tu prends 15 litres d’eau légèrement contaminée, tu les fais passer dans un filtre qui en produit 1 litre très pur (et jette le reste). Si ce litre n’est pas assez pur, tu recommences avec 15 litres de cette eau déjà filtrée. C’est coûteux — tu consommes beaucoup de matière première — mais tu atteins la pureté requise.

Le surcoût en qubits physiques — les chiffres qui font réfléchir

La distillation d’états magiques est extrêmement coûteuse. Voici les ordres de grandeur :

Ressource	Estimation
Qubits physiques par qubit logique (code de surface d=23)	~1 000
États |T⟩ pour Shor sur RSA-2048	~1 milliard
Qubits physiques totaux pour RSA-2048	~20 millions
Temps d’exécution estimé	~8 heures

Attention : Ces chiffres supposent un taux d’erreur physique de ~0.1%. Si le taux d’erreur est plus élevé, il faut augmenter la distance du code, ce qui fait exploser le nombre de qubits physiques. Inversement, des techniques émergentes comme les codes LDPC quantiques et les portes transversales non-Clifford pourraient réduire ce coût de 10× à 100×.

Où en est-on ? (2025-2026)

• Google Willow : 105 qubits physiques — loin des millions nécessaires
• IBM Heron : ~1 000 qubits
• Objectif industrie : ~10 000 qubits logiques dans les années 2030
• La distillation reste le goulot d’étranglement principal du FTQC

Distillation d’états magiques — simulation Qiskit

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
import numpy as np

def preparer_etat_magique_t():
    """
    Prépare un état magique |T⟩ = (|0⟩ + e^(iπ/4)|1⟩) / √2
    puis mesure sa fidélité après passage par un canal de bruit.
    """
    qc = QuantumCircuit(1, 1)

    # Préparer |T⟩ = T|+⟩ = T H|0⟩
    qc.h(0)       # |+⟩ = (|0⟩ + |1⟩) / √2
    qc.t(0)       # Applique T : phase e^(iπ/4) sur |1⟩
    # Résultat : (|0⟩ + e^(iπ/4)|1⟩) / √2

    return qc

def circuit_teleportation_porte_t():
    """
    Téléportation de porte T :
    - q0 : qubit de données (état quelconque à transformer)
    - q1 : état magique |T⟩ préparé
    - Résultat : T est appliquée à q0 via téléportation
    """
    qc = QuantumCircuit(2, 1)

    # Préparer un état de test sur q0
    qc.h(0)
    qc.barrier()

    # Préparer l'état magique |T⟩ sur q1
    qc.h(1)
    qc.t(1)
    qc.barrier()

    # Téléportation de porte :
    # 1) CNOT(q0, q1)
    qc.cx(0, 1)
    # 2) Mesurer q1
    qc.measure(1, 0)
    # 3) Si résultat = 1, appliquer correction S sur q0
    # (en simulation, on applique S conditionnellement)
    qc.s(0).c_if(0, 1)

    return qc

# Démonstration
circuit = circuit_teleportation_porte_t()
print(circuit.draw())

sim = AerSimulator()
result = sim.run(transpile(circuit, sim), shots=1024).result()
print("Résultats :", result.get_counts())
# → La porte T a été appliquée à q0 sans utiliser T directement
# C'est le principe de la tolérance aux fautes pour les portes non-Clifford

Porte T par téléportation de porte en Q#

// Q# — Téléportation de porte T (principe simplifié)
// En FTQC, on ne peut pas appliquer T transversalement.
// On consomme un état magique |T⟩ et on utilise la téléportation.

operation PreparerEtatMagique(cible : Qubit) : Unit {
    // Prépare |T⟩ = T|+⟩ = (|0⟩ + e^(iπ/4)|1⟩) / √2
    H(cible);
    T(cible);
}

operation TeleporterPorteT(donnee : Qubit) : Unit {
    // Appliquer la porte T sur 'donnee' via téléportation de porte
    use magique = Qubit();

    // 1) Préparer l'état magique
    PreparerEtatMagique(magique);

    // 2) CNOT entre donnée et état magique
    CNOT(donnee, magique);

    // 3) Mesurer l'état magique
    let resultat = M(magique);
    Reset(magique);

    // 4) Correction conditionnelle
    // Si le résultat est One, appliquer la porte S sur donnée
    if resultat == One {
        S(donnee);
    }

    // Résultat : T a été appliquée à 'donnee' de manière tolérante aux fautes
    Message("Porte T appliquée via téléportation de porte.");
}

operation DemoTeleportationT() : Result {
    use q = Qubit();

    // État initial arbitraire
    H(q);

    // Appliquer T via téléportation
    TeleporterPorteT(q);

    // Mesurer le résultat
    let r = M(q);
    Reset(q);
    return r;
}

Point clé : Dans un vrai système FTQC, l’état magique |T⟩ serait lui-même encodé dans un code de surface et distillé à travers plusieurs niveaux de purification. Le code ci-dessus montre le principe de la téléportation de porte au niveau des qubits physiques. Le surcoût réel apparaît quand on combine distillation + encodage logique + correction de syndromes — c’est là que les millions de qubits deviennent nécessaires.

---

Suprématie/avantage quantique

Qu’est-ce que la suprématie quantique ?

La suprématie quantique (ou avantage quantique computationnel) désigne le moment où un ordinateur quantique résout une tâche spécifique plus rapidement que n’importe quel ordinateur classique connu. Le terme a été proposé par John Preskill en 2012.

Attention : Le mot « suprématie » prête à confusion. Il ne signifie pas que l’ordinateur quantique est globalement meilleur qu’un ordinateur classique. Il signifie qu’il existe au moins une tâche pour laquelle la machine quantique fait mieux. Pour l’instant, ces tâches sont artificielles et sans application pratique directe.

Analogie : Imagine qu’un robot arrive à résoudre un Rubik’s Cube en 0.3 secondes alors que le meilleur humain met 3.5 secondes. Le robot a la « suprématie » sur cette tâche précise — mais ça ne veut pas dire qu’il est meilleur que l’humain pour cuisiner, conduire ou écrire du code. La suprématie quantique, c’est le Rubik’s Cube de l’informatique quantique.

Random Circuit Sampling — la tâche choisie par Google

La tâche que Google a choisie pour démontrer la suprématie s’appelle Random Circuit Sampling (RCS) — échantillonnage de circuits aléatoires.

Le principe :

1. On construit un circuit quantique composé de portes aléatoires appliquées sur n qubits
2. On exécute le circuit et on mesure tous les qubits
3. On répète des milliers de fois pour obtenir un échantillon de la distribution de probabilité du circuit
4. On vérifie que l’échantillon correspond bien à la distribution théorique (via un score appelé XEB — Cross-Entropy Benchmarking)

Pourquoi c’est dur classiquement ? Un circuit aléatoire profond (beaucoup de couches de portes) sur n qubits produit une distribution de probabilité sur 2ⁿ résultats possibles. Pour n = 53, c’est environ 9 × 10¹⁵ amplitudes complexes à calculer. Simuler cela classiquement requiert un temps et une mémoire exponentiels.

Analogie : Imagine que tu dois simuler le comportement d’un réseau de 53 routeurs, mais chaque routeur peut être dans une superposition de 2 états simultanément, et ils sont tous intriqués. Pour prédire la sortie, un simulateur classique doit explorer toutes les combinaisons possibles — 2⁵³ chemins. Le circuit quantique, lui, explore ces chemins « en parallèle » naturellement.

L’expérience Sycamore (2019) — 200 secondes vs 10 000 ans

En octobre 2019, Google a publié dans Nature les résultats de son processeur Sycamore :

Les faits :

• 53 qubits supraconducteurs (54 sur la puce, 1 défectueux)
• Circuit de 20 couches de portes à 1 et 2 qubits
• 1 million d’échantillons collectés en 200 secondes
• Google a estimé qu’un supercalculateur classique (Summit d’IBM) mettrait 10 000 ans pour la même tâche

La métrique XEB : Le score XEB mesure la qualité des échantillons. Un score de 0 = bruit aléatoire (pas mieux que le hasard). Un score de 1 = échantillons parfaits. Sycamore a atteint un score XEB d’environ 0.2% — faible en absolu, mais suffisamment au-dessus du bruit pour confirmer que les échantillons ne sont pas aléatoires.

Les contre-attaques classiques — IBM et les simulateurs tensoriels

La revendication de Google a immédiatement été contestée :

IBM (2019) : Quelques jours après l’annonce de Google, IBM a publié un article affirmant que Summit pourrait effectuer la tâche en 2.5 jours (pas 10 000 ans) en utilisant suffisamment de stockage disque pour compenser le manque de RAM. L’estimation de Google supposait une simulation purement en mémoire.

Améliorations avec les réseaux de tenseurs (2021-2024) :

• Des équipes chinoises et américaines ont montré que des méthodes de contraction de réseaux de tenseurs pouvaient simuler des circuits similaires en quelques heures à quelques jours sur des supercalculateurs modernes
• En 2024, des travaux ont réduit l’avantage à un facteur beaucoup plus modeste

Leçon importante : La suprématie quantique est une cible mouvante. Quand un ordinateur quantique démontre un avantage, les algorithmiciens classiques redoublent d’efforts pour trouver de meilleurs algorithmes classiques. L’avantage « 10 000 ans vs 200 secondes » s’est réduit considérablement.

Analogie : C’est comme le chiffrement. Tu crées un algorithme de chiffrement et tu annonces qu’il faudrait 10 000 ans pour le casser. Deux ans plus tard, quelqu’un trouve une attaque qui réduit ça à 3 jours. La sécurité perçue dépend de l’état de l’art des attaques, qui évolue constamment. La suprématie quantique fonctionne de la même manière — c’est une course entre la machine quantique et l’ingéniosité classique.

Conditions pour un avantage quantique « utile »

La communauté scientifique distingue trois niveaux d’avantage :

Niveau	Description	Atteint ?
Suprématie sur une tâche artificielle	Le quantique fait mieux sur RCS (sans utilité pratique)	Débattu
Avantage sur une tâche utile	Le quantique résout un problème pratique (chimie, optimisation) plus vite que le classique	Pas encore
Avantage tolérant aux fautes	Idem, mais avec correction d’erreur complète et comparaison juste	Lointain

Critères pour parler d’avantage utile :

1. La tâche doit être pratiquement pertinente — pas un problème artificiel construit pour avantager le quantique
2. Le coût quantique complet doit être compté — incluant la correction d’erreur, la distillation d’états magiques, le décodage classique des syndromes
3. La comparaison classique doit être juste — utiliser les meilleurs algorithmes classiques connus sur le meilleur hardware classique disponible
4. L’avantage doit être robuste — pas annulé par une amélioration algorithmique classique prévisible

Analogie : C’est comme benchmarker un nouveau framework. Si tu compares ton nouveau microservice Rust ultra-optimisé à un monolithe PHP 5.2 non optimisé sur un serveur de 2010, tu vas toujours « gagner ». Mais est-ce un benchmark honnête ? L’avantage quantique utile exige la même rigueur : comparer le meilleur quantique au meilleur classique, en comptant tous les coûts.

Simulation d’un mini Random Circuit Sampling en Qiskit

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit.circuit.library import UGate
import numpy as np

def random_circuit_sampling(n_qubits: int, depth: int, shots: int = 4096):
    """
    Mini Random Circuit Sampling :
    - Applique des couches alternées de portes aléatoires 1-qubit et CZ 2-qubits
    - Mesure et collecte des échantillons
    - Calcule un score XEB simplifié
    """
    qc = QuantumCircuit(n_qubits, n_qubits)

    for couche in range(depth):
        # Portes aléatoires 1-qubit sur chaque qubit
        for q in range(n_qubits):
            theta = np.random.uniform(0, np.pi)
            phi = np.random.uniform(0, 2 * np.pi)
            lam = np.random.uniform(0, 2 * np.pi)
            qc.append(UGate(theta, phi, lam), [q])

        # Portes CZ sur des paires alternées (pair-impair ou impair-pair)
        start = couche % 2
        for q in range(start, n_qubits - 1, 2):
            qc.cz(q, q + 1)

        qc.barrier()

    # Mesure finale
    qc.measure(range(n_qubits), range(n_qubits))

    # Exécuter
    sim = AerSimulator()
    result = sim.run(transpile(qc, sim), shots=shots).result()
    counts = result.get_counts()

    # Score XEB simplifié :
    # XEB = 2^n * <P(x)> - 1 où <P(x)> est la moyenne
    # des probabilités théoriques sur les échantillons obtenus
    n_total = 2 ** n_qubits
    xeb_approx = len(counts) / n_total  # Approximation : diversité des résultats
    print(f"Circuit : {n_qubits} qubits, profondeur {depth}")
    print(f"Résultats uniques : {len(counts)} / {n_total} possibles")
    print(f"Top 5 résultats : {dict(list(sorted(counts.items(), key=lambda x: -x[1]))[:5])}")

    return counts

# Petit exemple (4 qubits, profondeur 6)
# Sur un vrai Sycamore : 53 qubits, profondeur 20
resultats = random_circuit_sampling(n_qubits=4, depth=6, shots=4096)

Simulation simplifiée en Q# — circuit aléatoire

// Q# — Mini Random Circuit Sampling
// Démonstration du principe avec quelques qubits

operation PorteAleatoire(q : Qubit, seed : Int) : Unit {
    // Appliquer une rotation "pseudo-aléatoire" basée sur le seed
    // En Q# réel, on utiliserait des angles aléatoires via le host
    let angle = Microsoft.Quantum.Math.PI() * 0.3 * IntAsDouble(seed);
    Rx(angle, q);
    Ry(angle * 0.7, q);
    Rz(angle * 1.3, q);
}

operation RandomCircuitSampling(nQubits : Int, depth : Int) : Result[] {
    use qubits = Qubit[nQubits];

    for couche in 0..depth - 1 {
        // Couche de portes 1-qubit
        for idx in 0..nQubits - 1 {
            PorteAleatoire(qubits[idx], couche * nQubits + idx);
        }

        // Couche de portes CZ sur paires alternées
        let start = couche % 2;
        for idx in start..2..nQubits - 2 {
            // CZ = CNOT entouré de Hadamard
            H(qubits[idx + 1]);
            CNOT(qubits[idx], qubits[idx + 1]);
            H(qubits[idx + 1]);
        }
    }

    // Mesurer tous les qubits
    let resultats = Microsoft.Quantum.Arrays.ForEach(M, qubits);
    ResetAll(qubits);
    return resultats;
}

operation RunExperience() : Unit {
    // Lancer 100 échantillons (vs 1 million pour Sycamore)
    for shot in 0..99 {
        let bits = RandomCircuitSampling(4, 6);
        // En production, on collecterait ces résultats
        // et on calculerait le score XEB
    }
    Message("100 échantillons collectés.");
    Message("Sycamore en a collecté 1 million sur 53 qubits !");
}

Point clé : Avec 4 qubits, un ordinateur classique simule instantanément ce circuit. La difficulté classique n’apparaît qu’à partir de ~40-50 qubits, où le nombre d’amplitudes (2⁵⁰ ≈ 10¹⁵) dépasse la capacité mémoire de tout ordinateur classique. C’est cette frontière exponentielle que Google a voulu franchir avec Sycamore.

---