Plusieurs qubits et produit tensoriel & Intrication et états de Bell

Plusieurs qubits et produit tensoriel

Pourquoi combiner des qubits ?

Un seul qubit peut être dans une superposition de 2 états (|0⟩ et |1⟩). Deux qubits permettent de représenter 4 états simultanément, trois qubits → 8 états, et n qubits → 2ⁿ états. C’est cette croissance exponentielle qui donne sa puissance au calcul quantique.

Analogie développeur : le produit tensoriel (noté ⊗) c’est comme créer un Tuple<QubitA, QubitB> — l’espace des combinaisons possibles est le produit cartésien des deux espaces individuels. Si qubit A a 2 états possibles et qubit B en a 2, le système A⊗B a 2×2 = 4 états possibles.

Le vecteur d’état pour n qubits

Pour 2 qubits, l’état général s’écrit :

|ψ⟩ = α₀₀|00⟩ + α₀₁|01⟩ + α₁₀|10⟩ + α₁₁|11⟩

Les coefficients α sont des amplitudes (des nombres dont le carré donne la probabilité). La règle est toujours la même : la somme des carrés de toutes les amplitudes = 1.

Concrètement : |0⟩ ⊗ |1⟩ = |01⟩. On écrit les états côte à côte. Le premier qubit est “à gauche”, le second “à droite”.

Attention à l’ordre des qubits !

⚠️ Piège classique : Qiskit utilise la convention little-endian (le qubit 0 est le bit de poids faible, à droite). Q# utilise la convention big-endian côté API. Si tu crées un circuit avec q[0] et q[1] en Qiskit, le résultat de mesure "01" signifie q[1]=0, q[0]=1.

États séparables

Un état de 2 qubits est séparable s’il peut s’écrire comme le produit tensoriel de deux états individuels. Par exemple :

|+⟩ ⊗ |0⟩ = (|0⟩+|1⟩)/√2 ⊗ |0⟩ = (|00⟩+|10⟩)/√2

Cet état est séparable : chaque qubit a “sa propre vie”. Si un état n’est pas séparable, on dit qu’il est intriqué.

Code : créer un état à 2 qubits

// Q# — Mettre q0 en superposition, laisser q1 à |0⟩
// Résultat : état (|00⟩ + |10⟩) / √2  (séparable)
operation DeuxQubits() : (Result, Result) {
    use (q0, q1) = (Qubit(), Qubit());
    H(q0);                     // q0 → |+⟩
    let r0 = M(q0);            // mesure q0
    let r1 = M(q1);            // mesure q1
    Reset(q0); Reset(q1);
    return (r0, r1);           // ("Zero"|"One", "Zero") 50/50 pour q0
}

# Qiskit — même chose
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(2, 2)
qc.h(0)               # q[0] → |+⟩
qc.measure([0, 1], [0, 1])

sim = AerSimulator()
result = sim.run(qc, shots=1024).result()
print(result.get_counts())
# {'00': ~512, '01': ~512}
# Attention little-endian : '01' signifie q[0]=1, q[1]=0

Intrication et états de Bell

C’est quoi l’intrication ?

L’intrication est un lien entre deux (ou plus) qubits tel que l’état du système entier ne peut pas se décomposer en états individuels. Imagine deux dés magiques : quand tu lances le premier et obtiens 6, le deuxième donne immédiatement 6 aussi, peu importe la distance entre eux. Ce n’est pas une communication — c’est que les deux dés sont un seul objet quantique.

Formellement : un état à 2 qubits est intriqué s’il est impossible de l’écrire comme |a⟩ ⊗ |b⟩ pour des états individuels |a⟩ et |b⟩. Il est non-séparable.

Les 4 états de Bell

Les états de Bell sont les 4 états maximalement intriqués de 2 qubits — les “briques de base” de l’intrication :

L’état |Φ+⟩ est le plus célèbre. Si tu mesures le premier qubit et obtiens |0⟩, le second qubit est instantanément |0⟩ aussi (et inversement pour |1⟩). C’est 50/50 pour chaque résultat, mais les deux qubits sont toujours corrélés.

Le circuit de Bell : H + CNOT

Créer un état de Bell est étonnamment simple :

1. Appliquer une porte Hadamard (H) sur le premier qubit pour le mettre en superposition.
2. Appliquer une porte CNOT avec le premier qubit comme contrôle et le second comme cible.

La porte CNOT (Controlled-NOT) inverse le qubit cible uniquement si le qubit de contrôle est |1⟩. Combiné avec la superposition du H, cela crée l’intrication :

|00⟩ → H⊗I → (|00⟩+|10⟩)/√2 → CNOT → (|00⟩+|11⟩)/√2 = |Φ+⟩

⚠️ L’intrication n’est PAS de la communication instantanée. Quand tu mesures un qubit intriqué, l’autre “sait” immédiatement le résultat, mais tu ne peux pas utiliser ça pour envoyer un message. Le résultat est aléatoire — tu ne contrôles pas ce que tu obtiens. Pour transmettre de l’information utile, il faut toujours un canal classique. Einstein appelait ça “l’action fantomatique à distance”, mais c’est en réalité une corrélation, pas une communication.

Code : créer un état de Bell |Φ+⟩

// Q# — Créer l'état de Bell |Φ+⟩ et mesurer
operation BellState() : (Result, Result) {
    use (q0, q1) = (Qubit(), Qubit());
    H(q0);                     // superposition sur q0
    CNOT(q0, q1);              // intrication : q0 contrôle, q1 cible
    let r0 = M(q0);
    let r1 = M(q1);
    Reset(q0); Reset(q1);
    return (r0, r1);           // toujours (Zero,Zero) ou (One,One)
}

# Qiskit — Créer l'état de Bell |Φ+⟩ et mesurer
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(2, 2)
qc.h(0)                # H sur q[0]
qc.cx(0, 1)            # CNOT : contrôle=q[0], cible=q[1]
qc.measure([0, 1], [0, 1])

sim = AerSimulator()
result = sim.run(qc, shots=1024).result()
print(result.get_counts())
# {'00': ~512, '11': ~512}
# Jamais '01' ni '10' — les qubits sont intriqués !

Vérifier l’intrication : la non-séparabilité

Comment savoir si (|00⟩+|11⟩)/√2 est intriqué ? Essayons de l’écrire comme produit tensoriel :

(a|0⟩+b|1⟩) ⊗ (c|0⟩+d|1⟩) = ac|00⟩ + ad|01⟩ + bc|10⟩ + bd|11⟩

Pour obtenir (|00⟩+|11⟩)/√2, il faudrait ac = 1/√2, bd = 1/√2, mais ad = 0 et bc = 0. Si a≠0 et d≠0 (car ac et bd non nuls), alors ad≠0 — contradiction ! Donc cet état est non-séparable, donc intriqué.