Estimation de ressources et réalisme industriel

Qubit logique vs qubit physique : le vrai prix

Avant de croire un titre « notre machine a 1000 qubits ! », il faut savoir de quels qubits on parle. C’est la distinction la plus importante de tout le domaine industriel.

• Un qubit physique est un dispositif réel (transmon supraconducteur, ion piégé…), bruité et instable.
• Un qubit logique est un qubit « parfait » simulé en encodant l’information sur beaucoup de qubits physiques, via un code correcteur d’erreur. L’algorithme (Shor, Grover) raisonne en qubits logiques ; le matériel paie la facture en qubits physiques.

Analogie ingénieur (RAID). Un disque logique fiable construit sur N disques physiques peu fiables : plus tu veux de fiabilité, plus tu ajoutes de redondance. Ici c’est pareil, mais le « facteur RAID » est énorme — des centaines à des milliers de qubits physiques par qubit logique.

Le surcoût du code de surface

Avec un code de surface (le candidat n°1 pour le matériel supraconducteur), un qubit logique de distance de code d coûte environ 2·d² qubits physiques. Augmenter d supprime l’erreur logique exponentiellement — mais seulement si l’erreur physique est sous le seuil du code (~1 %). Au-dessus du seuil, ajouter des qubits empire les choses.

À retenir. La qualité des qubits (taux d’erreur) compte davantage que leur nombre brut. Un matériel avec moins de qubits mais une erreur 10× plus faible peut être plus proche de l’utilité réelle.

La métrique qui domine le coût : le T-count

En calcul tolérant aux fautes, les portes de Clifford (H, CNOT, S) sont « gratuites » à protéger. La porte non-Clifford T exige un état magique distillé — une opération coûteuse. Le T-count (et la T-depth) pilote donc le temps d’exécution réel, souvent plus que le nombre de qubits logiques.

Piège. « 1000 qubits annoncés » = qubits physiques bruités (régime NISQ), pas des qubits logiques. Casser RSA demande des qubits logiques tolérants aux fautes. Les deux chiffres diffèrent de 3 à 4 ordres de grandeur.

Casser RSA-2048 : les vrais chiffres

L’estimation de référence (Gidney & Ekerå, 2019/2021) : factoriser RSA-2048 avec l’algorithme de Shor demande de l’ordre de ~20 millions de qubits physiques bruités pendant ~8 heures, en supposant une erreur physique ~10⁻³ et un code de surface. Cela ne représente que quelques milliers de qubits logiques — mais multipliés par l’énorme surcoût de correction.

Le coût explose à cause de l’exponentiation modulaire contrôlée au cœur de Shor : un T-count colossal ⇒ d’immenses « usines » de distillation d’états magiques, qui dominent le budget en qubits et en temps.

Logique → physique, illustré

Quelques milliers de qubits logiques semblent modestes. Mais à d ≈ 27, on a déjà 2·27² ≈ 1458 qubits physiques par qubit logique — d’où les dizaines de millions. Réduire l’erreur physique d’un facteur 10 permet de réduire d, donc le coût total, de façon spectaculaire.

À retenir. Aucun matériel de 2025 n’approche ces chiffres. Mais l’attaque « harvest now, decrypt later » (intercepter et stocker aujourd’hui pour déchiffrer plus tard) rend la migration vers la cryptographie post-quantique urgente dès maintenant — voir l’inégalité de Mosca ci-dessous.

Estimer les ressources soi-même + calendriers crédibles

L’Azure Quantum Resource Estimator prend un programme Q# ou Qiskit et ne l’exécute pas : il compte les ressources (qubits logiques, T-count, profondeur), puis applique un modèle de code de surface + des paramètres matériels pour estimer qubits physiques, runtime et nombre d’usines de distillation. C’est l’outil idéal pour comparer des scénarios sans matériel réel.

On lui fournit des hypothèses : modèle de qubit (qubit_gate_ns_e3 = supraconducteur rapide, erreur 10⁻³), schéma de correction (surface_code) et budget d’erreur.

# Azure Quantum Resource Estimator via le paquet qsharp (Python)
import qsharp
from qsharp.estimator import EstimatorParams, QubitParams, QECScheme

qsharp.eval('''
operation FactorDemo() : Unit {
    use qs = Qubit[2048];
    // ... exponentiation modulaire + QFT inverse (Shor) ...
}''')

params = EstimatorParams()
params.qubit_params.name = QubitParams.GATE_NS_E3   # supraconducteur, err ~1e-3
params.qec_scheme.name   = QECScheme.SURFACE_CODE   # code de surface
params.error_budget      = 0.01                     # budget d'erreur global

res = qsharp.estimate("FactorDemo()", params=params)
# res["physicalCounts"] → qubits physiques, runtime, nb d'usines d'états magiques
# res["logicalCounts"]  → qubits logiques, tCount, profondeur
print(res["physicalCounts"]["physicalQubits"])
print(res["physicalCounts"]["runtime"])  # en nanosecondes

// Côté Q# : on ANNOTE l'algorithme ; le Resource Estimator est une cible
// d'exécution (comme un simulateur) qui compte les T-gates et les qubits
// SANS aucun matériel quantique.
operation EstimerCout() : Unit {
    use registre = Qubit[100];
    // Chaque T() consommera un état magique distillé → pèse sur le T-count.
    T(registre[0]);                                   // Étape coûteuse (non-Clifford)
    H(registre[1]); CNOT(registre[1], registre[2]);   // Clifford : "gratuit"
}
// Exécuter avec la cible ResourcesEstimator → rapport qubits / T-count.

Calendriers crédibles & inégalité de Mosca

L’inégalité de Mosca formalise l’urgence : si X (durée de confidentialité requise des données) + Y (temps pour migrer vers la PQC) > Z (temps avant un ordinateur quantique cryptographiquement pertinent), alors tu es déjà en retard. C’est pourquoi on migre maintenant, même si « Q-Day » reste lointain et incertain.

Lecture critique. Un communiqué « N qubits » sans préciser logiques vs physiques, le taux d’erreur et la connectivité n’a aucune valeur pour estimer une menace. Le bon réflexe d’ingénieur : « combien de qubits logiques, à quelle erreur ? »