Distribution quantique de clés (QKD) & Avantages et limites des PQC paramétrés

Distribution quantique de clés (QKD)

L’idée en une phrase

QKD permet à Alice et Bob de partager une clé secrète dont la sécurité repose sur les lois de la physique — pas sur la difficulté d’un problème mathématique.

Pourquoi c’est différent de la crypto classique

RSA/AES reposent sur des hypothèses computationnelles (factorisation difficile, etc.). Un ordinateur quantique assez puissant casse RSA via Shor. QKD, lui, est information-theoretically secure : même un attaquant avec une puissance de calcul infinie ne peut pas obtenir la clé sans être détecté.

Le secret : le théorème de non-clonage. Un espion (Eve) ne peut pas copier un qubit inconnu pour l’analyser discrètement. Toute interception perturbe l’état et laisse des traces statistiques.

Le protocole BB84

Inventé par Bennett et Brassard en 1984. Le plus simple et le plus déployé :

1. Alice génère des bits aléatoires et les encode dans des qubits, en choisissant aléatoirement la base Z (|0⟩, |1⟩) ou la base X (|+⟩, |−⟩).
2. Bob mesure chaque qubit dans une base choisie aléatoirement (Z ou X).
3. Réconciliation des bases : Alice et Bob comparent publiquement leurs choix de bases (pas les résultats !). Ils ne gardent que les bits où la base coïncide (~50 % en moyenne).
4. Détection d’espion : ils sacrifient un sous-ensemble de bits pour estimer le taux d’erreur quantique (QBER). Si QBER > ~11 %, Eve est présente → abandon.

# BB84 simplifié en Qiskit — Alice encode, Bob mesure
from qiskit import QuantumCircuit

def bb84_round(alice_bit, alice_base, bob_base):
    """Simule un échange BB84 pour 1 qubit."""
    qc = QuantumCircuit(1, 1)
    # Alice encode le bit
    if alice_bit == 1:
        qc.x(0)             # bit = 1
    if alice_base == 'X':
        qc.h(0)             # passe en base X
    qc.barrier()
    # Bob mesure dans sa base
    if bob_base == 'X':
        qc.h(0)             # mesure en base X
    qc.measure(0, 0)
    return qc

# Cas favorable : mêmes bases → Bob retrouve le bit d'Alice
qc = bb84_round(alice_bit=1, alice_base='X', bob_base='X')
# Résultat : Bob mesure 1 avec certitude (bases concordantes)

Le protocole E91

Proposé par Ekert en 1991. Ici Alice et Bob partagent des paires intriquées (états de Bell) :

• Chaque partie mesure son qubit dans une base choisie parmi 3 options. Les bases communes donnent la clé ; les bases différentes servent à tester la violation de l’inégalité de Bell (CHSH).
• Si Eve intercepte un qubit, elle détruit l’intrication → la violation de Bell diminue → détection.

⚠️ Piège fréquent : QKD ne permet PAS de communiquer plus vite que la lumière. Un canal classique authentifié est toujours nécessaire pour la réconciliation des bases. QKD distribue une clé, pas un message.

Limitations pratiques

• Distance : ~100 km en fibre optique (pertes exponentielles). Les répéteurs quantiques restent expérimentaux.
• Débit : ~1 kbit/s à 100 km. Trop faible pour un one-time-pad sur des flux réels → on utilise QKD pour renouveler fréquemment les clés AES.
• Coût : matériel spécialisé (sources de photons uniques, détecteurs supraconducteurs SPD), infrastructure dédiée.

Avantages et limites des PQC paramétrés

Qu’est-ce qu’un PQC ?

Un Parameterized Quantum Circuit (PQC) est un circuit quantique dont certaines portes (rotations Ry, Rz…) dépendent de paramètres θ ajustables. C’est l’analogue quantique d’un réseau de neurones :

• On fixe une architecture (ansatz) : nombre de couches, portes, connectivité.
• Un optimiseur classique ajuste les θ pour minimiser une fonction de coût (énergie dans VQE, perte dans QML…).
• C’est le moteur des algorithmes hybrides : VQE, QAOA, QNN, classifieurs quantiques.

# Un PQC simple : 2 qubits, 1 couche — ansatz hardware-efficient
from qiskit.circuit import QuantumCircuit, Parameter

theta = [Parameter(f'θ_{i}') for i in range(4)]
qc = QuantumCircuit(2)
# Couche 1 : rotations locales
qc.ry(theta[0], 0)
qc.ry(theta[1], 1)
# Intrication entre voisins
qc.cx(0, 1)
# Couche 2 : rotations locales
qc.ry(theta[2], 0)
qc.ry(theta[3], 1)
print(qc.draw())

Expressibilité vs entraînabilité

Deux propriétés fondamentales d’un ansatz, en tension l’une avec l’autre :

⚠️ Le dilemme : un circuit très expressif explore uniformément l’espace de Hilbert → les gradients s’annulent (barren plateau). Un circuit peu expressif est entraînable mais risque de ne pas pouvoir représenter la solution.

Barren plateaus — le problème central

Imaginez chercher une vallée dans un paysage. Un barren plateau, c’est comme si le paysage était parfaitement plat à perte de vue : votre boussole (le gradient) ne pointe nulle part.

• La variance du gradient décroît exponentiellement avec n qubits : Var(∂C/∂θ) ∝ 1/2ⁿ. Pour n = 50, le gradient est noyé dans le bruit statistique.
• Causes principales : circuits trop profonds, ansatz trop expressif (2-design), fonctions de coût globales.
• Ce n’est PAS du bruit matériel. Les barren plateaus existent même en simulation parfaite.

Stratégies pour éviter les barren plateaus

# Parameter-shift rule pour calculer un gradient
from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.primitives import StatevectorEstimator
from qiskit.quantum_info import SparsePauliOp
import numpy as np

# Circuit paramétré simple
theta = Parameter('θ')
qc = QuantumCircuit(1)
qc.ry(theta, 0)

# Observable : mesure en Z
obs = SparsePauliOp('Z')

# Parameter-shift rule :
# ∂C/∂θ = [C(θ + π/2) − C(θ − π/2)] / 2
estimator = StatevectorEstimator()
val = 0.5  # valeur courante de θ
shift = np.pi / 2

job_plus  = estimator.run([(qc, obs, [val + shift])])
job_minus = estimator.run([(qc, obs, [val - shift])])

gradient = (job_plus.result()[0].data.evs - job_minus.result()[0].data.evs) / 2
print(f"Gradient en θ={val:.2f} : {gradient:.4f}")

⚠️ Piège : « Hardware-efficient ansatz » ne veut pas dire « meilleur ansatz ». Ces circuits deviennent souvent victimes de barren plateaus au-delà de ~20 qubits. Un ansatz problem-aware (UCCSD, Hamiltonian variational) est généralement préférable quand la structure du problème est connue.