Qubits, superpositie en verstrengeling: kwantumfundamenten zonder kwantumfysica
Elke introductie tot kwantumcomputers lijkt te beginnen met de kwantummechanica, de vergelijkingen Schrödinger en de dualiteit van golven en deeltjes. Het resultaat is dat de meeste ontwikkelaars je verdwaalt in de fysieke details voordat je zelfs maar begrijpt waarom een kwantumcomputer anders is dan een kwantumcomputer klassiek. Dit artikel doet het tegenovergestelde: het legt de fundamentele concepten uit: qubits, superpositie, verstrengeling en decoherentie – met behulp van toegankelijke wiskundige analogieën en Qiskit-code kan dat rennen nu.
Je hoeft de kwantummechanica niet te kennen. Je hebt vectoren en waarschijnlijkheden nodig.
Wat je gaat leren
- Wat is wiskundig een qubit: vector in 2D Hilbertruimte
- De Bloch-bol: visualisatie van de toestand van een qubit
- Superpositie: waarschijnlijkheid, geen magie
- Verstrengeling: kwantumcorrelatie zonder communicatie
- Decoherentie: waarom kwantumcomputers moeilijk zijn
- Maatregel: de ineenstorting van de staat en de gevolgen ervan
- Alle Qiskit-code om elk concept te visualiseren
Het klassieke bit versus de Qubit
Een klassiek bit heeft precies één van twee waarden: 0 of 1. Fysisch gezien is het een transistor die stroom geleidt of niet geleidt. Er is geen dubbelzinnigheid: de bit bevindt zich altijd in een gedefinieerde toestand.
Een qubit wordt wiskundig beschreven door a vector in een 2-hilbertruimte afmetingen. De algemene toestand van een qubit is:
|ψ⟩ = α|0⟩ + β|1⟩
dove:
|0⟩ e il vettore [1, 0] (stato base "zero")
|1⟩ e il vettore [0, 1] (stato base "uno")
α e β sono numeri complessi (ampiezze)
con il vincolo: |α|² + |β|² = 1
La probabilita di misurare 0 e |α|²
La probabilita di misurare 1 e |β|²
Dit is het kritische punt: α en β zijn geen waarschijnlijkheden; het zijn amplitudes. De kansen worden verkregen door de grootte van de amplitudes te kwadrateren. Dit onderscheid en fundamenteel omdat de amplitudes kunnen interfereren (elkaar optellen of opheffen) als golven, terwijl klassieke waarschijnlijkheden dat niet doen.
# Visualizzare lo stato di un qubit con Qiskit
from qiskit import QuantumCircuit
from qiskit.visualization import plot_bloch_multivector, plot_histogram
from qiskit.quantum_info import Statevector
import numpy as np
# Stato |0⟩ — qubit "a zero"
qc_zero = QuantumCircuit(1)
sv_zero = Statevector.from_instruction(qc_zero)
print(f"Stato |0⟩: {sv_zero}")
# Statevector([1.+0.j, 0.+0.j], dims=(2,))
# probabilita di misurare 0: |1|^2 = 1.0 (100%)
# probabilita di misurare 1: |0|^2 = 0.0 (0%)
# Stato |1⟩ — applico gate X (equivalente al NOT classico)
qc_one = QuantumCircuit(1)
qc_one.x(0)
sv_one = Statevector.from_instruction(qc_one)
print(f"Stato |1⟩: {sv_one}")
# Statevector([0.+0.j, 1.+0.j], dims=(2,))
# Stato in superposizione — applico gate Hadamard
qc_plus = QuantumCircuit(1)
qc_plus.h(0) # Hadamard: |0⟩ -> (|0⟩ + |1⟩)/√2
sv_plus = Statevector.from_instruction(qc_plus)
print(f"Stato |+⟩ (superposizione): {sv_plus}")
# Statevector([0.707+0.j, 0.707+0.j], dims=(2,))
# probabilita 0: 0.707^2 = 0.5 (50%)
# probabilita 1: 0.707^2 = 0.5 (50%)
# Verifica le probabilita
probs = sv_plus.probabilities_dict()
print(f"Probabilita di misura: {probs}")
# {'0': 0.4999..., '1': 0.4999...}
De Bloch-bol: een Qubit visualiseren
De Bloch-bol is een bol met straal 1, waarbij elk punt op het oppervlak een toestand vertegenwoordigt puur kwantum (één qubit). De noordpool is |0⟩, de zuidpool is |1⟩. De punten op de evenaar het zijn equiprobeerbare superposities van |0⟩ en |1⟩.
# Visualizzare vari stati sulla Bloch sphere
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
def show_state_on_bloch(circuit: QuantumCircuit, label: str) -> None:
sv = Statevector.from_instruction(circuit)
probs = sv.probabilities_dict()
print(f"\nStato: {label}")
print(f"Statevector: {sv.data}")
print(f"P(0)={probs.get('0', 0):.3f}, P(1)={probs.get('1', 0):.3f}")
# Polo Nord: |0⟩
qc_north = QuantumCircuit(1)
show_state_on_bloch(qc_north, "|0⟩ (polo nord)")
# Polo Sud: |1⟩
qc_south = QuantumCircuit(1)
qc_south.x(0)
show_state_on_bloch(qc_south, "|1⟩ (polo sud)")
# Equatore: |+⟩ = (|0⟩ + |1⟩)/√2 — Hadamard da |0⟩
qc_plus = QuantumCircuit(1)
qc_plus.h(0)
show_state_on_bloch(qc_plus, "|+⟩ (equatore, fase reale +)")
# Equatore: |−⟩ = (|0⟩ - |1⟩)/√2 — X poi Hadamard
qc_minus = QuantumCircuit(1)
qc_minus.x(0)
qc_minus.h(0)
show_state_on_bloch(qc_minus, "|−⟩ (equatore, fase reale -)")
# Stato arbitrario: rotazione di pi/4 attorno all'asse Y
qc_ry = QuantumCircuit(1)
qc_ry.ry(np.pi/4, 0) # Rotazione Y di 45 gradi
show_state_on_bloch(qc_ry, "RY(π/4)|0⟩ (stato intermedio)")
# P(0) ≈ 0.854, P(1) ≈ 0.146
De conceptuele sleutel: de Hadamard-poort "zet de qubit niet als het ware in superpositie". een dubbelzinnige fysieke positie. Roteert de toestandsvector van de noordpool naar de evenaar van de Bloch-bol. De "superpositie" is eenvoudigweg de qubit die in één richting wijst verschillend van |0⟩ en |1⟩.
Interferentie: de ware kracht van Quantum
Superpositie alleen is niet nuttig; een qubit in superpositie meet je alleen een willekeurig stukje. De ware kracht van quantum computing komt voort uitinterferentie: de amplitudes kunnen elkaar optellen (constructieve interferentie) of opheffen (destructieve interferentie), waardoor u paden die naar het juiste antwoord leiden, kunt versterken en de verkeerde kunt onderdrukken.
# Interferenza: l'Hadamard applicato due volte
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
# H applicato due volte torna allo stato iniziale (interferenza perfetta)
qc_hh = QuantumCircuit(1)
qc_hh.h(0) # Prima H: |0⟩ -> |+⟩ = (|0⟩+|1⟩)/√2
qc_hh.h(0) # Seconda H: le ampiezze interferiscono
sv = Statevector.from_instruction(qc_hh)
print(f"H|H|0⟩ = {sv.data}")
# [1.+0.j, 0.+0.j] — torna esattamente a |0⟩!
# Perche? La matematica:
# Prima H: [1/√2, 1/√2]
# Seconda H: il gate applica la matrice [[1/√2, 1/√2], [1/√2, -1/√2]]
# Risultato: [1/√2*1/√2 + 1/√2*1/√2, 1/√2*1/√2 - 1/√2*1/√2]
# = [1, 0] = |0⟩
# Il termine per |1⟩ si annulla (interferenza distruttiva)!
# Gli algoritmi quantum sfruttano questa interferenza:
# - Amplificano stati con la risposta giusta (interferenza costruttiva)
# - Sopprimono stati con risposte sbagliate (interferenza distruttiva)
Verstrengeling: kwantumcorrelatie
Verstrengeling is het tweede fundamentele concept. Twee verstrengelde qubits hebben gecorreleerde toestanden: de meting van de één bepaalt onmiddellijk het resultaat van de meting van de ander, onafhankelijk van afstand. Maar – en dit is het punt waarop veel artikelen de fout in gaan – dit is niet het geval maakt communicatie sneller dan het licht mogelijk.
De Bell-status is het eenvoudigste voorbeeld van 2-qubit-verstrengeling:
# Creare e misurare il Bell State
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit_aer import AerSimulator
from qiskit import transpile
# Crea il Bell State |Φ+⟩ = (|00⟩ + |11⟩) / √2
qc_bell = QuantumCircuit(2, 2)
qc_bell.h(0) # Superposizione sul qubit 0
qc_bell.cx(0, 1) # CNOT: se qubit 0 e |1⟩, nega qubit 1
# Lo stato e: (|00⟩ + |11⟩) / √2
# NON e separabile: impossibile scrivere come |a⟩ ⊗ |b⟩
sv = Statevector.from_instruction(qc_bell)
print(f"Bell State: {sv.data}")
# [0.707, 0, 0, 0.707] -> 50% |00⟩, 50% |11⟩
# Misura
qc_bell.measure([0, 1], [0, 1])
simulator = AerSimulator()
compiled = transpile(qc_bell, simulator)
result = simulator.run(compiled, shots=10000).result()
counts = result.get_counts()
print(f"Risultati (10000 shots): {counts}")
# Solo '00' e '11' — MAI '01' o '10'!
# Se qubit 0 e 0, qubit 1 e sempre 0. Se qubit 0 e 1, qubit 1 e sempre 1.
# Questo e l'entanglement: non si manifesta come comunicazione
# ma come CORRELAZIONE perfetta nelle misure.
# "Misuro il qubit 0: ottengo 0. So con certezza che qubit 1 sara 0."
# La correlazione vale anche se i due qubit sono a chilometri di distanza.
# Einstein chiamava questo "spooky action at a distance" — e reale e verificato.
Omdat verstrengeling geen communicatie mogelijk maakt: wanneer u uw qubit meet, je krijgt een willekeurig resultaat (0 of 1 met elk een waarschijnlijkheid van 50%). Alleen als je communiceert Als dit resultaat via het klassieke kanaal aan de andere persoon wordt doorgegeven, begrijpt ze wat ze heeft. Het kanaal klassiek – dat wordt beperkt door de snelheid van het licht – is altijd nodig om informatie te extraheren nuttig.
Decoherentie: de vijand van kwantumcomputing
De reden waarom het bouwen van kwantumcomputers zo moeilijk is, is decoherentie: qubits interageren met de omgeving (thermische fotonen, magnetische velden, trillingen) en lekken hun kwantumeigenschappen, die in klassieke toestanden vervallen. Dit proces vindt plaats in microseconden op de huidige hardware.
# Simulare l'effetto della decoerenza con noise model
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, depolarizing_error
from qiskit import QuantumCircuit, transpile
# Noise model semplice: errore di depolarizzazione dopo ogni gate
noise_model = NoiseModel()
error_1qubit = depolarizing_error(0.01, 1) # 1% di errore per gate a 1 qubit
error_2qubit = depolarizing_error(0.05, 2) # 5% di errore per gate a 2 qubit
noise_model.add_all_qubit_quantum_error(error_1qubit, ['h', 'x', 'ry'])
noise_model.add_all_qubit_quantum_error(error_2qubit, ['cx'])
# Test: Bell state con e senza noise
def run_bell(shots: int, noisy: bool = False) -> dict:
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
if noisy:
sim = AerSimulator(noise_model=noise_model)
else:
sim = AerSimulator()
compiled = transpile(qc, sim)
result = sim.run(compiled, shots=shots).result()
return result.get_counts()
ideal = run_bell(10000, noisy=False)
noisy = run_bell(10000, noisy=True)
print("Senza noise:")
for state, count in sorted(ideal.items()):
print(f" |{state}⟩: {count/10000*100:.1f}%")
print("\nCon noise (1% per gate, 5% per CNOT):")
for state, count in sorted(noisy.items()):
print(f" |{state}⟩: {count/10000*100:.1f}%")
# Output tipico con noise:
# |00⟩: ~49%, |11⟩: ~49%, |01⟩: ~1%, |10⟩: ~1%
# Gli stati '01' e '10' compaiono a causa del noise — "bit flip errors"
Analogie van ontwikkelaars voor sleutelconcepten
- Qubits: een variabele die 0, 1 of een verdeling van kan zijn waarschijnlijkheid groter dan {0,1} — maar als je het "leest" (meet), stort het in tot 0 of 1
- Superpositie: de variabele bevindt zich in de status "nog niet bepaald". — zoals een belofte vóór oplossing(). De meting en de oplossing()
- Verstrengeling: twee variabelen met gegarandeerde perfecte correlatie — zoals twee objecten die een onveranderlijke referentie delen, maar de waarde niet kennen tot "lezen"
- Interferentie: Berekeningspaden toevoegen/annuleren als golven — hiermee kunt u het juiste antwoord versterken
- Decoherentie: quantum bit rot — het systeem verliest zijn eigenschappen kwantum door interferentie met de omgeving
Meten en samenvouwen
De meting en werking die klassieke informatie uit een kwantumtoestand haalt – bijv vernietigt de staat onherstelbaar. En een fundamentele beperking van kwantumcomputers: je kunt de tussenliggende status van een berekening niet "lezen" zonder deze te vernietigen.
# Il collasso della misura: dimostrazione pratica
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
# Crea superposizione
qc = QuantumCircuit(1)
qc.h(0)
sv_before = Statevector.from_instruction(qc)
print(f"Prima della misura: {sv_before.data}")
# [0.707+0j, 0.707+0j] — superposizione
# Misura (simulata 1000 volte)
qc_measure = QuantumCircuit(1, 1)
qc_measure.h(0)
qc_measure.measure(0, 0)
from qiskit_aer import AerSimulator
from qiskit import transpile
sim = AerSimulator()
compiled = transpile(qc_measure, sim)
result = sim.run(compiled, shots=1000).result()
print(f"Dopo 1000 misure: {result.get_counts()}")
# {'0': ~500, '1': ~500}
# Punto critico: ogni singola misura collassa il qubit
# Non puoi misurare |+⟩ e poi continuare a lavorarci
# Devi preparare di nuovo lo stato dall'inizio
# Questo e perche no-cloning theorem: non puoi copiare uno stato sconosciuto
Conclusies
De fundamentele concepten van kwantumcomputers: qubits, superpositie, verstrengeling en decoherentie – ze zijn allemaal te beschrijven met lineaire algebra en waarschijnlijkheid, zonder esoterische fysica. Bloch bol- en Qiskit-toestandsvectoren zijn concrete hulpmiddelen om ze te visualiseren en ermee te werken.
Het volgende artikel bouwt voort op deze fundamenten: kwantumpoorten als transformaties lineair, de constructie van het eerste echte algoritme (Bell-status) en uitvoering op IBM-hardware.