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’estimation de ressources consiste à prendre un circuit quantique et, sans l’exécuter, à compter les ressources nécessaires (qubits logiques, T-count, profondeur), puis à appliquer un modèle de code de surface + des paramètres matériels pour estimer qubits physiques, runtime et nombre d’usines de distillation. Avec Qiskit, on peut réaliser cette estimation en transpilant le circuit vers un jeu Clifford+T puis en comptant les portes — c’est l’outil idéal pour comparer des scénarios sans matériel réel.

On fournit des hypothèses : le circuit à analyser, le jeu de portes cible (basis gates), le niveau d’optimisation, et on inspecte les opérations résultantes pour en extraire le T-count et la profondeur.

# Estimation de ressources avec Qiskit : transpiler vers Clifford+T
# puis compter les portes T (la métrique de coût dominante en FTQC).
from qiskit import QuantumCircuit, transpile

# Circuit simplifié illustrant le principe (Shor complet aurait ~2048 qubits)
qc = QuantumCircuit(4, name="FactorDemo")
qc.h(0)
qc.cx(0, 1)
qc.t(1)              # porte T : non-Clifford, coûteuse en FTQC
qc.cx(1, 2)
qc.t(2)
qc.cx(2, 3)
qc.h(3)

# Transpiler vers le jeu Clifford+T pour compter les ressources
tqc = transpile(qc, basis_gates=['h', 's', 't', 'cx', 'tdg', 'sdg'],
                optimization_level=3)

ops = tqc.count_ops()
t_count = ops.get('t', 0) + ops.get('tdg', 0)  # T-count total
cx_count = ops.get('cx', 0)                      # CNOT count
depth = tqc.depth()

print(f"T-count : {t_count}")
print(f"CNOT count : {cx_count}")
print(f"Profondeur : {depth}")
print(f"Qubits logiques : {tqc.num_qubits}")
# En FTQC : chaque qubit logique coûte ~2·d² qubits physiques (code de surface).
# Avec d ≈ 27 → ~1458 physiques par logique. Multiplier pour le coût total.

# Compter le coût relatif des portes : T (non-Clifford) vs Clifford
from qiskit import QuantumCircuit, transpile

qc = QuantumCircuit(3, name="EstimerCout")
qc.t(0)              # Porte T → exige un état magique distillé (coûteux)
qc.h(1)              # Clifford : « gratuit » en FTQC
qc.cx(1, 2)          # Clifford : « gratuit » en FTQC

tqc = transpile(qc, basis_gates=['h', 's', 't', 'cx', 'tdg', 'sdg'],
                optimization_level=2)
ops = tqc.count_ops()
print(f"Opérations : {ops}")
print(f"T-count (coût dominant) : {ops.get('t', 0) + ops.get('tdg', 0)}")
# Le T-count pilote le runtime réel en calcul tolérant aux fautes.

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 ? »