Représentations d'états mixtes & Algorithme de Shor — vue d'ensemble

Thème A — Représentations d’états mixtes

Pourquoi la matrice densité ?

Jusqu’ici, on représentait un qubit par un vecteur d’état (ket) : |ψ⟩. Mais imaginez une boîte noire qui prépare |0⟩ avec 50 % de chances et |+⟩ avec 50 %. Vous ne savez pas lequel elle a choisi — c’est une incertitude classique par-dessus l’incertitude quantique.

Analogie : un vecteur d’état, c’est savoir exactement quelle carte vous tenez. Une matrice densité, c’est savoir « 50 % chance d’un as, 50 % d’un roi » — vous pouvez toujours calculer vos espérances de gain.

La matrice densité ρ est une matrice 2×2 (pour un qubit) qui encode à la fois l’état quantique et notre ignorance classique. Toute mesure, toute évolution, peut se calculer avec ρ.

États purs vs états mixtes

Exemple crucial — ne confondez pas ces deux situations :

• Superposition |+⟩ = (|0⟩ + |1⟩)/√2 → état pur. ρ = |+⟩⟨+|. tr(ρ²) = 1.
• Mélange classique « 50 % |0⟩, 50 % |1⟩ » → état mixte. ρ = ½|0⟩⟨0| + ½|1⟩⟨1| = ½ I. tr(ρ²) = ½.

Attention : La superposition |+⟩ et le mélange 50/50 donnent les mêmes probabilités de mesure dans la base Z, mais ce ne sont PAS le même état. Mesurez dans la base X pour les distinguer !

Trace partielle

Quand vous avez 2 qubits intriqués mais que vous ne pouvez observer que le premier, vous « tracez » (éliminez) le second. Le résultat est une matrice densité pour votre qubit seul.

Analogie : dans un jeu de cartes où les mains sont corrélées, regarder uniquement votre main donne une vue « floue » — même si l’ensemble des deux mains est parfaitement défini.

Conséquence fondamentale : si deux qubits sont intriqués (état pur global), la trace partielle donne un état mixte pour chaque qubit individuellement. C’est la signature mathématique de l’intrication.

Opérateurs de Kraus

Les opérateurs de Kraus décrivent comment le bruit ou l’environnement transforme un qubit. Un canal quantique s’écrit : ρ → Σₖ Eₖ ρ Eₖ†, où chaque Eₖ représente « une chose possible que l’environnement fait ».

Condition : Σₖ Eₖ† Eₖ = I (les probabilités totalisent 1). Vous reverrez les Kraus en détail dans les fiches sur la correction d’erreur et la décohérence.

Code — Qiskit DensityMatrix

# Qiskit : créer et comparer états pur vs mixte
from qiskit.quantum_info import DensityMatrix, Statevector
import numpy as np

# État pur |+⟩
sv_plus = Statevector.from_label('+')
rho_pure = DensityMatrix(sv_plus)
print("ρ pur (|+⟩) :")
print(rho_pure)
print("tr(ρ²) =", np.real(rho_pure.purity()))  # → 1.0

# État mixte : 50% |0⟩ + 50% |1⟩
rho_mixed = 0.5 * DensityMatrix.from_label('0') + 0.5 * DensityMatrix.from_label('1')
print("\nρ mixte (50% |0⟩, 50% |1⟩) :")
print(rho_mixed)
print("tr(ρ²) =", np.real(rho_mixed.purity()))  # → 0.5

Code — Q# (conceptuel)

// Q# ne manipule pas directement les matrices densité,
// mais on peut simuler un état mixte avec un bit classique :
operation PrepareMixedState() : Result {
    use q = Qubit();
    // Tirage classique : 50% |0⟩, 50% |1⟩
    let coin = DrawRandomBool(0.5);
    if coin {
        X(q);  // prépare |1⟩
    }
    // sinon, le qubit reste |0⟩
    let result = M(q);
    Reset(q);
    return result;
}

Thème B — Algorithme de Shor — vue d’ensemble

Le problème : factoriser de grands nombres

RSA repose sur un fait simple : multiplier deux grands nombres premiers p et q est facile, mais retrouver p et q à partir de N = p × q est extrêmement difficile classiquement.

Analogie : mélanger deux pots de peinture (rouge + bleu = violet) est instantané. « Dé-mélanger » le violet pour retrouver les couleurs d’origine ? Quasi impossible.

L’idée de Shor : factoriser = trouver l’ordre

Shor a montré que factoriser N se réduit à trouver l’ordre r d’un nombre a modulo N — c’est le plus petit entier r tel que a^r ≡ 1 (mod N).

Les étapes :

1. Choisir un a au hasard (1 < a < N).
2. Vérifier que gcd(a, N) = 1 (sinon on a déjà un facteur !).
3. Utiliser QPE (estimation de phase quantique) pour trouver r.
4. Si r est pair, calculer gcd(a^(r/2) ± 1, N) → facteurs de N.

Le rôle de QPE

QPE trouve la phase de l’opérateur unitaire U défini par U|x⟩ = |ax mod N⟩. Les valeurs propres de U sont de la forme e^(2πi·s/r), et QPE extrait s/r. On utilise ensuite les fractions continues pour isoler r.

C’est exactement dans QPE que vit l’accélération quantique — le reste de l’algorithme est classique.

Complexité

Avec un ordinateur quantique tolérant aux fautes disposant de ~4 000 qubits logiques.

Conséquences cryptographiques

• RSA-2048 serait cassé en temps polynomial par Shor.
• La cryptographie post-quantique (Kyber pour le chiffrement, Dilithium pour les signatures) est conçue pour résister même à un ordinateur quantique.
• Timeline : on estime qu’il faudra des milliers de qubits logiques (donc des millions de qubits physiques avec correction d’erreur). Pas pour demain, mais les organisations migrent dès maintenant.

Attention : Shor ne casse que la crypto à clé publique basée sur la factorisation ou le logarithme discret (RSA, ECC). AES-256 reste sûr (Grover ne fait que diviser la sécurité par 2 en bits).

Code — Circuit de Shor simplifié (Qiskit)

# Shor simplifié pour N=15, a=7 (démonstration)
from qiskit import QuantumCircuit
from qiskit.circuit.library import QFT

n_count = 3  # qubits de comptage (précision QPE)

qc = QuantumCircuit(n_count + 4, n_count)

# 1. Superposition sur les qubits de comptage
for q in range(n_count):
    qc.h(q)

# 2. Initialiser le registre de travail à |1⟩
qc.x(n_count)

# 3. Exponentiation modulaire contrôlée (simplifié pour a=7, N=15)
# En pratique, c'est la partie la plus complexe du circuit
for q in range(n_count):
    power = 2 ** q
    # On appliquerait ici : controlled-U^(2^q)
    # U|x⟩ = |7^(2^q) * x mod 15⟩
    pass  # circuit réel omis pour clarté

# 4. QFT inverse sur les qubits de comptage
qc.append(QFT(n_count, inverse=True), range(n_count))

# 5. Mesure
qc.measure(range(n_count), range(n_count))
print(qc)

Code — Q# (structure)

// Q# : structure logique de l'algorithme de Shor
// (simplifié — la vraie implémentation nécessite
//  l'exponentiation modulaire quantique)
operation ShorOrder(a : Int, N : Int, nQubits : Int) : Int {
    use counting = Qubit[nQubits];
    use target = Qubit[4];

    // 1. Superposition
    ApplyToEach(H, counting);

    // 2. Initialiser |1⟩
    X(target[0]);

    // 3. Exponentiation modulaire contrôlée
    // (chaque qubit de comptage contrôle U^(2^k))
    // → Implémentation spécifique à (a, N)

    // 4. QFT inverse
    Adjoint QFT(counting);

    // 5. Mesurer et extraire r via fractions continues
    let result = MeasureInteger(counting);
    ResetAll(target);
    return result;
}