Bits classiques vs qubits & Superposition et mesure

Bits classiques vs qubits

L’idée en une phrase

Un bit classique est un interrupteur : allumé (1) ou éteint (0). Un qubit est plutôt comme une pièce qui tourne en l’air — tant qu’elle tourne, elle n’est ni pile ni face, mais elle a une certaine tendance à tomber sur l’un ou l’autre.

Analogie : Imagine un curseur de volume qui va de 0% à 100%. Un bit classique ne peut être qu’à 0% ou 100%. Un qubit, lui, peut être réglé n’importe où entre les deux — mais quand tu appuies sur « lecture » (= mesure), le son sort soit à 0% soit à 100%, jamais entre les deux. Le réglage du curseur détermine la probabilité de chaque résultat.

Points clés

• Un qubit a deux « réglages » internes qu’on appelle des amplitudes. Ce sont des nombres qui décrivent la tendance du qubit à donner 0 ou 1 quand on le mesure.
• On note l’état d’un qubit avec la notation de Dirac : |0⟩ signifie « l’état qui donne toujours 0 à la mesure », |1⟩ signifie « toujours 1 ». Un état général s’écrit a|0⟩ + b|1⟩ où a et b sont les amplitudes.
• Règle d’or : la probabilité d’obtenir 0 = (amplitude de |0⟩)² et la probabilité d’obtenir 1 = (amplitude de |1⟩)². Ces deux probabilités doivent toujours faire 100% au total.
• On ne peut pas copier un qubit (contrairement à un bit classique). C’est le « théorème de non-clonage » — pas de var copy = qubit; en quantique !

Exemple concret

Si un qubit a une amplitude de 0.6 pour |0⟩ et 0.8 pour |1⟩ :

• Probabilité de mesurer 0 = 0.6 × 0.6 = 0.36 (soit 36%)
• Probabilité de mesurer 1 = 0.8 × 0.8 = 0.64 (soit 64%)
• Total : 36% + 64% = 100%

Comparaison bit vs qubit

Code Q# — allouer et mesurer un qubit

// Q# : un qubit naît toujours dans l'état |0⟩
// Donc si on le mesure tout de suite -> toujours "Zero"
operation MeasureDefault() : Result {
    use q = Qubit();       // crée un qubit (état = |0⟩)
    let result = M(q);     // mesure -> forcément Zero
    Reset(q);              // remettre à |0⟩ (obligatoire avant de libérer)
    return result;         // -> Zero à chaque fois
}

Code Qiskit — créer et mesurer un qubit

# Qiskit : même chose en Python
from qiskit import QuantumCircuit
from qiskit.primitives import Sampler

qc = QuantumCircuit(1, 1)   # 1 qubit + 1 bit classique pour le résultat
qc.measure(0, 0)            # mesurer le qubit -> résultat dans le bit

sampler = Sampler()
result = sampler.run(qc, shots=1024).result()
# Résultat : {'0': 1.0} -> toujours 0, car le qubit part en |0⟩

Piège courant : « Un qubit est 0 et 1 en même temps » est un raccourci FAUX. Un qubit est dans un état qui a une certaine tendance vers 0 et une certaine tendance vers 1. Quand on mesure, on obtient un seul résultat — jamais les deux.

Superposition et mesure

L’idée en une phrase

La superposition, c’est quand un qubit n’est pas fixé sur |0⟩ ou |1⟩ — il est « entre les deux », avec des tendances définies par ses amplitudes. La mesure force le qubit à « choisir » : une fois mesuré, il est définitivement dans l’état trouvé.

Analogie : Pense à un dé truqué. Tant que tu ne l’as pas lancé, le résultat n’existe pas — mais le dé a des propriétés internes (son poids, sa forme) qui déterminent les probabilités. Lancer le dé = mesurer. Après le lancer, le résultat est fixé, et tu ne peux pas « re-truquer » le dé pour retrouver son état d’avant.

Points clés

• L’état |+⟩ est LA superposition de base : le qubit a exactement 50% de chances de donner 0 et 50% de donner 1. C’est comme une pièce parfaitement équilibrée.
• Pour créer |+⟩ à partir de |0⟩, on utilise la porte Hadamard (notée H). En code : H(q) en Q# ou qc.h(0) en Qiskit.
• La mesure est destructive : une fois qu’on a mesuré, la superposition est perdue. Le qubit est désormais dans l’état trouvé (|0⟩ ou |1⟩). C’est irréversible.
• Hadamard est son propre inverse : appliquer H deux fois de suite = ne rien faire. H(H(|0⟩)) = |0⟩. C’est comme faire un aller-retour.
• Il existe aussi l’état |−⟩ : mêmes probabilités 50/50 que |+⟩, mais avec une « phase » différente (un signe moins interne). À la mesure directe, |+⟩ et |−⟩ sont impossibles à distinguer.

Comment distinguer |+⟩ de |−⟩ ?

On applique H avant de mesurer. C’est comme « changer de lunettes » pour voir la différence :

• H appliqué à |+⟩ donne |0⟩ → mesure = toujours 0
• H appliqué à |−⟩ donne |1⟩ → mesure = toujours 1

Tableau récapitulatif

Code Q# — créer une superposition

// Q# : Hadamard met le qubit en superposition 50/50
operation SuperpositionDemo() : Result {
    use q = Qubit();       // état initial : |0⟩
    H(q);                  // Hadamard -> maintenant en |+⟩ (50/50)
    let result = M(q);     // mesure : ~50% Zero, ~50% One
    Reset(q);
    return result;
}

// Astuce : H appliqué deux fois = retour à l'état initial
operation DoubleH() : Result {
    use q = Qubit();
    H(q);                  // |0⟩ -> |+⟩
    H(q);                  // |+⟩ -> |0⟩ (retour !)
    let result = M(q);     // -> toujours Zero
    Reset(q);
    return result;
}

Code Qiskit — superposition et mesure

# Qiskit : Hadamard + mesure = pile ou face quantique
from qiskit import QuantumCircuit
from qiskit.primitives import Sampler

qc = QuantumCircuit(1, 1)
qc.h(0)           # Hadamard : |0⟩ -> |+⟩ (superposition)
qc.measure(0, 0)  # mesure : 50% '0', 50% '1'

sampler = Sampler()
result = sampler.run(qc, shots=1024).result()
# -> {'0': ~0.5, '1': ~0.5}  (environ moitié-moitié)

Piège courant : |+⟩ et |−⟩ donnent les mêmes résultats (50/50) si on mesure directement. Leur différence est une « phase interne » invisible à la mesure directe. Pour les distinguer, il faut appliquer H avant de mesurer.