La sphère de Bloch & Portes mono-qubit fondamentales

La sphère de Bloch

L’idée intuitive

Imagine un globe terrestre. Chaque point sur la surface du globe représente un état possible d’un qubit. Le pôle Nord, c’est |0⟩. Le pôle Sud, c’est |1⟩. Tous les points entre les deux ? Ce sont des superpositions — des mélanges de |0⟩ et |1⟩ avec différentes proportions et différentes « phases ».

À retenir : La sphère de Bloch est une représentation visuelle en 3D de l’état d’un seul qubit. Chaque point sur la surface = un état pur.

Les deux angles : θ et φ

Pour repérer un point sur une sphère, on utilise deux angles :

• θ (thêta) — l’angle « du haut vers le bas », de 0 à π (180°). Il contrôle la proportion entre |0⟩ et |1⟩. θ = 0 → pôle Nord (|0⟩). θ = π → pôle Sud (|1⟩). θ = π/2 → équateur (50/50).
• φ (phi) — l’angle « autour de l’équateur », de 0 à 2π (360°). Il contrôle la phase relative entre les composantes |0⟩ et |1⟩. C’est comme tourner un cadran sur le ventre du globe.

L’état général s’écrit : |ψ⟩ = cos(θ/2)|0⟩ + e^(iφ) sin(θ/2)|1⟩. Pas de panique si la formule semble complexe : retiens juste que θ dit « combien de |1⟩ » et φ dit « dans quelle direction sur l’équateur ».

États remarquables

État	Position sur la sphère	θ	φ
|0⟩	Pôle Nord	0	—
|1⟩	Pôle Sud	π	—
|+⟩ = (|0⟩+|1⟩)/√2	Équateur, face avant (+X)	π/2	0
|−⟩ = (|0⟩−|1⟩)/√2	Équateur, face arrière (−X)	π/2	π
|i⟩ = (|0⟩+i|1⟩)/√2	Équateur, droite (+Y)	π/2	π/2
|−i⟩ = (|0⟩−i|1⟩)/√2	Équateur, gauche (−Y)	π/2	3π/2

Rotations Rx, Ry, Rz

Appliquer une porte quantique sur un qubit, c’est comme faire tourner le point sur la sphère autour d’un axe :

• Rx(α) — rotation d’un angle α autour de l’axe X. Fait basculer entre |0⟩ et |1⟩ en passant par |i⟩ / |−i⟩.
• Ry(α) — rotation autour de l’axe Y. Fait basculer entre |0⟩ et |1⟩ en passant par |+⟩ / |−⟩.
• Rz(α) — rotation autour de l’axe Z. Tourne autour de l’équateur sans changer les probabilités de mesurer |0⟩ ou |1⟩ — ne change que la phase.

À retenir : Rz change la phase (φ) mais pas les probabilités. Rx et Ry changent les probabilités ET la phase.

Phase globale vs phase relative

Imagine que tu multiplies l’état entier du qubit par un nombre complexe de module 1, par exemple e^(iα). Ça ne change rien aux résultats de mesure : c’est une phase globale, invisible et sans effet physique. Par contre, la phase relative (la différence de phase entre les composantes |0⟩ et |1⟩) est bien réelle : elle détermine où le qubit se trouve sur l’équateur et influence les interférences dans les circuits.

⚠ Piège classique : Confondre phase globale et phase relative. Multiplier tout l’état par e^(iπ) = −1 ne change rien de mesurable. Mais ajouter une phase e^(iπ) uniquement devant |1⟩ (ce que fait la porte Z) transforme |+⟩ en |−⟩ — un effet bien réel.

Code : visualiser la sphère de Bloch en Qiskit

# Qiskit — placer un qubit à l'état |+⟩ et visualiser
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector

qc = QuantumCircuit(1)
qc.h(0)  # Hadamard → |+⟩ = (|0⟩+|1⟩)/√2

state = Statevector.from_instruction(qc)
plot_bloch_multivector(state)  # Affiche le point sur l'équateur (+X)

Code : rotation Ry en Q#

// Q# — appliquer une rotation Ry de π/2 (envoie |0⟩ vers |+⟩)
operation DemoRy() : Result {
    use q = Qubit();       // |0⟩ — pôle Nord
    Ry(PI() / 2.0, q);    // rotation de 90° autour de Y → |+⟩
    let result = M(q);     // mesure : 50% |0⟩, 50% |1⟩
    Reset(q);
    return result;
}

---

Portes mono-qubit fondamentales

Le concept de porte quantique

En programmation classique, tu appelles des méthodes sur des objets pour changer leur état. En quantique, c’est pareil : une porte quantique est une opération qui transforme l’état d’un qubit. La contrainte ? Toute porte doit être unitaire — c’est-à-dire réversible. Tu peux toujours « défaire » une porte en appliquant son inverse (sa conjuguée hermitienne, notée † — prononcé « dague »).

À retenir : Porte unitaire = réversible. Pour toute porte U, il existe U† telle que U†·U = identité. En Q#, on utilise Adjoint pour obtenir U†.

Les portes de Pauli : X, Y, Z

Pense à X, Y, Z comme des rotations de 180° autour des axes correspondants de la sphère de Bloch :

• X (NOT quantique) — rotation de π autour de l’axe X. Échange |0⟩ ↔ |1⟩. C’est le « bit flip ». Équivalent du NOT classique.
• Y — rotation de π autour de l’axe Y. Échange |0⟩ ↔ |1⟩ mais ajoute aussi des phases i et −i.
• Z (phase flip) — rotation de π autour de l’axe Z. Laisse |0⟩ intact mais multiplie |1⟩ par −1. Pas d’effet visible en mesure directe, mais crucial pour les interférences.

À retenir : Chaque porte de Pauli est son propre inverse : X·X = Y·Y = Z·Z = identité. On dit qu’elles sont involutives.

Hadamard (H)

La porte H est le couteau suisse du calcul quantique. Elle crée une superposition parfaite à partir d’un état de base :

• H|0⟩ = |+⟩ = (|0⟩ + |1⟩)/√2 — superposition avec phase positive
• H|1⟩ = |−⟩ = (|0⟩ − |1⟩)/√2 — superposition avec phase négative

Sur la sphère de Bloch, H correspond à une rotation de π autour de l’axe diagonal entre X et Z. Et comme les Pauli, Hadamard est son propre inverse : H·H = identité.

Portes S et T

• S (quart de tour de phase) — ajoute une phase de i (= e^(iπ/2)) à |1⟩. C’est Rz(π/2). On a S·S = Z.
• T (huitième de tour de phase) — ajoute une phase de e^(iπ/4) à |1⟩. C’est Rz(π/4). On a T·T = S.

S et T sont essentielles pour construire n’importe quelle porte à partir d’un jeu universel. Contrairement à X, Y, Z, H : ni S ni T ne sont leur propre inverse. L’inverse de S est S† (= Rz(−π/2)), et l’inverse de T est T† (= Rz(−π/4)).

Récapitulatif des portes

Porte	Effet	Involutive ?	Q#	Qiskit
X	Bit flip : |0⟩↔|1⟩	Oui (X² = I)	X(q)	qc.x(0)
Y	Bit + phase flip	Oui (Y² = I)	Y(q)	qc.y(0)
Z	Phase flip : |1⟩ → −|1⟩	Oui (Z² = I)	Z(q)	qc.z(0)
H	Crée / détruit superposition	Oui (H² = I)	H(q)	qc.h(0)
S	Phase π/2 sur |1⟩	Non (S² = Z)	S(q)	qc.s(0)
T	Phase π/4 sur |1⟩	Non (T² = S)	T(q)	qc.t(0)

⚠ Piège : Z n’a aucun effet visible si tu mesures directement après. Z\|0⟩ = \|0⟩ et Z\|1⟩ = −\|1⟩, mais la probabilité de mesurer |1⟩ est toujours |−1|² = 1. L’effet de Z n’apparaît que quand il y a interférence plus tard dans le circuit (par ex. après un H).

Code : enchaîner des portes en Qiskit

# Qiskit — H puis Z puis H = X (démonstration d'interférence)
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc = QuantumCircuit(1)
qc.h(0)   # |0⟩ → |+⟩
qc.z(0)   # |+⟩ → |−⟩  (phase flip, invisible sans le H final)
qc.h(0)   # |−⟩ → |1⟩  (interférence destructive sur |0⟩)

sv = Statevector.from_instruction(qc)
print(sv)  # [0.+0.j, 1.+0.j] → 100% |1⟩
# Résultat : H·Z·H = X  (bit flip via interférence !)

Code : même circuit en Q#

// Q# — H·Z·H = X : interférence en action
operation HZH_equals_X() : Result {
    use q = Qubit();   // |0⟩
    H(q);              // → |+⟩
    Z(q);              // → |−⟩
    H(q);              // → |1⟩ (interférence)
    let r = M(q);      // toujours One
    Reset(q);
    return r;          // Result: One
}

---