Suprématie/avantage quantique & Estimation de ressources et réalisme industriel

Suprématie & avantage quantique

Deux idées qu’on confond souvent — et que tout ingénieur devrait séparer.

• Suprématie quantique : une machine quantique accomplit une tâche — même artificielle et sans utilité — qu’aucun ordinateur classique ne peut faire en temps raisonnable. C’est une démonstration de principe.
• Avantage quantique utile : la machine résout plus vite un problème dont quelqu’un a réellement besoin (chimie, optimisation, finance). C’est le vrai Graal — pas encore atteint.

Analogie développeur. La suprématie, c’est un benchmark de synthèse qui ne reflète aucune charge réelle. L’avantage utile, c’est un gain mesuré sur votre vraie application en production.

Random Circuit Sampling (RCS)

La tâche choisie par Google pour Sycamore (2019). On tire un circuit quantique au hasard, on l’exécute, on mesure des milliers de fois. La distribution des chaînes de bits a une « signature tachetée » (speckle) propre à ce circuit. La reproduire classiquement oblige à simuler tout l’état quantique, dont le coût explose exponentiellement avec le nombre de qubits.

• Sycamore : 53 qubits, ~20 couches de portes.
• Annonce : ~200 secondes sur le processeur quantique vs ~10 000 ans sur le meilleur supercalculateur (estimation Google).

Vérifier sans pouvoir simuler : le XEB

Comment prouver que la machine a bien calculé si on ne peut pas refaire le calcul classiquement ? Avec le Linear Cross-Entropy Benchmarking (XEB) : un score mesurant à quel point les chaînes mesurées tombent sur les sorties « probables » du circuit. XEB ≈ 1 → comportement quantique idéal ; XEB ≈ 0 → bruit pur.

# Qiskit — un mini « random circuit sampling » sur 5 qubits
from qiskit.circuit.random import random_circuit
from qiskit_aer import AerSimulator

qc = random_circuit(5, depth=12, measure=True)   # circuit tiré au hasard
counts = AerSimulator().run(qc, shots=4096).result().get_counts()
# 'counts' est la distribution « tachetée », signature du circuit.
# À 5 qubits c'est trivial ; à 53 qubits, la simuler dépasse
# les meilleurs supercalculateurs -> démonstration de suprématie.

# Qiskit — échantillonner un circuit pseudo-aléatoire (version explicite)
from qiskit import QuantumCircuit
import numpy as np

def echantillonner_circuit(n: int, couches: int = 12) -> QuantumCircuit:
    qc = QuantumCircuit(n)
    for _ in range(couches):
        for q in range(n):
            qc.h(q); qc.t(q)                  # portes mono-qubit
        for i in range(n - 1):
            qc.cx(i, i + 1)                    # intrication entre voisins
    qc.measure_all()
    return qc
# Répété des milliers de fois -> distribution dont la simulation
# classique explose exponentiellement avec le nombre de qubits.

Les contre-attaques classiques

Le seuil de « suprématie » est une cible mouvante : améliorer l’algorithme classique repousse la frontière.

• IBM (2019) : avec un meilleur usage du stockage disque, l’estimation tombe de ~10 000 ans à ~2,5 jours.
• Méthodes de contraction de réseaux de tenseurs (tensor networks) : simulations encore plus rapides, parfois en heures sur GPU.

⚠️ Suprématie ≠ utilité. Le RCS ne sert à rien d’autre qu’à la démonstration. Et toute annonce de suprématie peut être « rétro-cassée » par un meilleur algorithme classique : ce n’est jamais un acquis définitif.

Estimation de ressources & réalisme industriel

Qubit logique ≠ qubit physique

Analogie. Un qubit physique est comme un disque dur bon marché qui tombe en panne sans arrêt. Pour stocker une information fiable, on en assemble des dizaines en « RAID » : c’est le qubit logique.

Le ratio est brutal — souvent ~1000 qubits physiques pour 1 qubit logique (correction d’erreur).

• Les annonces marketing comptent les qubits physiques (bruités).
• Le travail utile se mesure en qubits logiques (corrigés).
• Ne jamais confondre les deux.

Casser RSA-2048 avec Shor : le vrai devis

Shor casse RSA en théorie. Mais le devis industriel, correction d’erreur incluse, est vertigineux :

Ces chiffres viennent de l’estimation Gidney–Ekerå (2019). Le facteur d’explosion (milliers → millions) est entièrement dû à la correction d’erreur.

Estimation de ressources avec Qiskit

On transpile l’algorithme avec Qiskit et on compte les portes (profondeur, portes T) pour estimer — sous des hypothèses (taux d’erreur physique, distance de code, nombre d’usines à T) — le nombre de qubits physiques et la durée. On change un paramètre, on voit le coût bouger : un vrai outil d’ingénieur.

# Qiskit — compter les ressources d'un circuit (proxy d'estimation)
from qiskit import QuantumCircuit, transpile

qc = QuantumCircuit(4)
# ... circuit de Shor : exponentiation modulaire + QFT inverse ...
qc_transpiled = transpile(qc, basis_gates=['cx', 'rz', 'sx', 'x', 't', 'tdg'])

ops = qc_transpiled.count_ops()
print("Profondeur :", qc_transpiled.depth())
print("Portes T   :", ops.get("t", 0) + ops.get("tdg", 0))
print("CNOT       :", ops.get("cx", 0))
# L'estimateur ne simule pas le circuit : il compte les portes T,
# la profondeur, applique un code de surface de distance d, puis déduit
#   -> nb de qubits PHYSIQUES (~millions) et la durée (~heures).

# Qiskit — profondeur et portes T pilotent le coût réel
ops = qc.count_ops()
print("Profondeur :", qc.depth())
print("Portes T   :", ops.get("t", 0) + ops.get("tdg", 0))
# En calcul tolérant aux fautes, CHAQUE porte T coûte une distillation
# d'état magique. C'est ce comptage — pas le nombre de qubits — qui
# domine le devis final.

Calendriers crédibles & ère NISQ

Aujourd’hui : ère NISQ (Noisy Intermediate-Scale Quantum) — des machines de 50 à ~1000 qubits physiques bruités, sans correction d’erreur. Elles ne peuvent pas faire tourner Shor sur RSA-2048 : les circuits seraient bien trop profonds pour le bruit actuel.

⚠️ « 1 million de qubits » ne veut rien dire sans préciser : physiques ou logiques ? quel taux d’erreur ? quelle profondeur de circuit soutenable ? Empiler des qubits bruités ne rapproche pas de RSA tant qu’on n’a pas franchi le seuil de tolérance aux fautes.