Codes de surface & Estimation de ressources et réalisme industriel

Codes de surface

L’idée centrale

Un code de surface est un code correcteur d’erreurs quantiques qui dispose ses qubits sur un réseau 2D (une grille carrée). L’information logique (un seul qubit logique) est encodée dans l’état collectif de tous les qubits du réseau — aucun qubit individuel ne « contient » l’information.

Analogie : imagine un message secret réparti sur un puzzle de 100 pièces. Si tu perds 1 ou 2 pièces, le message reste lisible. Le code de surface fonctionne de la même manière avec les erreurs quantiques.

Architecture du réseau

Le réseau contient deux types de qubits :

• Qubits de données — situés sur les arêtes du réseau. Ce sont eux qui portent l’information logique de façon distribuée.
• Qubits d’ancilla (syndrome) — situés sur les sommets et les faces. Ils ne stockent rien : ils servent à mesurer les erreurs sans perturber les données.

Chaque qubit d’ancilla mesure un stabilisateur — un produit d’opérateurs de Pauli sur ses voisins :

• Stabilisateurs Z (sur les sommets) : mesurent le produit Z⊗Z⊗Z⊗Z des 4 qubits de données adjacents. Résultat = 0 → pas d’erreur de type X (bit-flip) à proximité. Résultat = 1 → une erreur X s’est produite quelque part autour de ce sommet.
• Stabilisateurs X (sur les faces) : mesurent X⊗X⊗X⊗X. Ils détectent les erreurs de type Z (phase-flip).

⚠ Piège courant : les mesures de syndrome ne lisent jamais l’état logique. Elles mesurent uniquement la parité des erreurs. C’est ce qui permet de corriger sans effondrer l’information quantique.

Distance et capacité de correction

La distance d d’un code de surface est le nombre minimal d’erreurs physiques qu’il faut pour transformer un état logique en un autre sans être détecté. Un code de distance d corrige jusqu’à ⌊(d − 1) / 2⌋ erreurs.

Exemple concret : avec d = 5, on corrige au plus 2 erreurs simultanées. Si 3 erreurs se produisent sur un chemin traversant le réseau, le décodeur peut confondre avec un opérateur logique → l’information est corrompue.

Distance d	Qubits de données	Erreurs corrigées	Taux d’erreur logique (p_phys = 10⁻³)
3	~9	1	~10⁻⁴
5	~25	2	~10⁻⁷
7	~49	3	~10⁻¹⁰
13	~169	6	~10⁻²⁰
27	~729	13	~10⁻⁴⁰+

Pourquoi le code de surface domine

• Il ne nécessite que des interactions nearest-neighbor sur un réseau 2D. Les puces supraconductrices (Google Sycamore, IBM Heron) ont exactement cette topologie. Pas besoin de connectivité longue-distance.
• Son seuil de tolérance (~1% d’erreur par porte) est l’un des plus élevés parmi tous les codes correcteurs. Si le taux d’erreur physique est en dessous de ce seuil, augmenter d améliore exponentiellement la fiabilité logique.

En Qiskit : mesure d’un stabilisateur Z

from qiskit import QuantumCircuit

# Code de surface minimal : 4 qubits de données + 1 ancilla
qc = QuantumCircuit(5, 1)

# Stabilisateur Z sur un sommet : Z₀ ⊗ Z₁ ⊗ Z₂ ⊗ Z₃
# On utilise des CNOT depuis chaque qubit de données vers l'ancilla (qubit 4)
for data_qubit in [0, 1, 2, 3]:
    qc.cx(data_qubit, 4)  # Propage la parité Z vers l'ancilla

# Mesurer l'ancilla → résultat du syndrome
qc.measure(4, 0)

# Si résultat = 0 : pas d'erreur X détectée
# Si résultat = 1 : une erreur X s'est produite sur l'un des 4 qubits
print(qc.draw())

---

Estimation de ressources et réalisme industriel

Le fossé logique / physique

Un qubit logique est un qubit protégé par un code correcteur. Pour le construire, il faut de nombreux qubits physiques. Avec un code de surface de distance d, chaque qubit logique coûte environ 2d² qubits physiques (données + ancillas).

Analogie : un qubit logique, c’est comme un disque RAID en informatique classique. Tu veux stocker 1 To de données fiables ? Tu as besoin de 3 ou 4 disques physiques. En quantique, le « ratio RAID » est bien plus élevé — de l’ordre de 1 000 à 5 000 qubits physiques par qubit logique.

L’exemple phare : casser RSA-2048

L’algorithme de Shor pour factoriser un nombre RSA-2048 nécessite environ 4 000 qubits logiques. Avec un code de surface de distance ~27 et un taux d’erreur physique de 10⁻³, cela se traduit en environ 20 millions de qubits physiques.

L’étude de référence est celle de Gidney & Ekerå (2021), qui a optimisé le circuit de Shor et estimé : ~20M qubits physiques, ~8 heures de calcul. C’est une réduction massive par rapport aux premières estimations (~1 milliard de qubits), mais ça reste très loin des machines actuelles (~1 000-1 500 qubits physiques).

Où passent tous ces qubits ?

Composant	Qubits physiques	% du total
Qubits logiques de données (registres Shor)	~4 000 × 2d² ≈ 5,8M	~30%
T-factories (distillation de magic states)	~12-14M	~65%
Routage et ancillas supplémentaires	~1M	~5%

Les T-factories dominent. Les portes T (non-Clifford) ne peuvent pas être appliquées directement de manière tolérante aux fautes — il faut « distiller » des magic states à l’aide de circuits correcteurs supplémentaires. Chaque T-factory est elle-même un mini code de surface.

Azure Quantum Resource Estimator

Microsoft propose un outil qui prend un programme Q# (ou un circuit) et calcule les ressources nécessaires pour l’exécuter sur du matériel réel :

# Utilisation de l'Azure Quantum Resource Estimator (Python SDK)
from azure.quantum import Workspace
from azure.quantum.target.microsoft import MicrosoftEstimator

# Connexion et configuration
estimator = MicrosoftEstimator(workspace)

# Paramètres : code de surface, budget d'erreur de 1%
params = estimator.make_params(num_items=1)
params.error_budget = 0.01
params.qubit_params.name = "qubit_gate_ns_e3"  # Taux d'erreur 10⁻³

# Soumettre un programme Q# compilé
job = estimator.submit(my_qsharp_program, input_params=params)
result = job.get_results()

# Résultats clés
print(f"Qubits logiques : {result['logicalCounts']['numQubits']}")
print(f"Qubits physiques : {result['physicalCounts']['physicalQubits']}")
print(f"Distance de code : {result['logicalQubit']['codeDistance']}")
print(f"T-factories : {result['tfactory']['numTfactories']}")
print(f"Temps d'exécution : {result['physicalCounts']['runtime']}")

Machines actuelles vs besoins

Machine (2024-2025)	Qubits physiques	Taux d’erreur 2-qubit	Suffisant pour RSA-2048 ?
IBM Heron (r2)	156	~0.3%	Non (×130 000)
Google Willow	105	~0.3%	Non (×190 000)
Quantinuum H2	56 (ions)	~0.1%	Non (×360 000)
Objectif RSA-2048	~20 000 000	< 0.1%	Oui

⚠ Ne pas confondre : quand un fabricant annonce « 1 000 qubits », ce sont des qubits physiques — des qubits bruyants, non corrigés. La capacité de calcul utile (en qubits logiques) est bien moindre, voire nulle pour les algorithmes nécessitant une correction d’erreur complète.

Calendriers crédibles

• Court terme (2025-2028) : avantage quantique sur des problèmes spécifiques (simulation moléculaire, optimisation) avec des algorithmes hybrides (VQE, QAOA) sur 100-1 000 qubits — sans correction d’erreur complète.
• Moyen terme (2028-2035) : premiers qubits logiques fonctionnels en continu, démonstrations de correction d’erreur à grande échelle, 10 000+ qubits physiques.
• Long terme (2035+) : machines de 1M+ qubits physiques, FTQC, applications industrielles réelles (chimie, optimisation, cryptanalyse). RSA-2048 reste un objectif lointain.

---