Hello World : ton premier circuit quantique

Construis un état de Bell (deux qubits intriqués) et exécute-le de trois manières :

1. Simulation idéale — résultats parfaits, aucun compte requis

2. Simulation bruitée — simule un véritable appareil, aucun compte requis

3. Matériel quantique réel — nécessite un compte IBM Quantum gratuit (étapes de configuration ci-dessous)

Construire le circuit

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"qiskit": "qiskit", "qiskit_ibm_runtime": "qiskit-ibm-runtime"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

from qiskit import QuantumCircuit

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

qc.draw(output="mpl")

Option 1 : Simulation idéale (aucun compte requis)

Utilise StatevectorSampler — un simulateur local avec des résultats parfaits, sans bruit.

from qiskit.primitives import StatevectorSampler

result = StatevectorSampler().run([qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
counts

from qiskit.visualization import plot_histogram
plot_histogram(counts)

Option 2 : Simulation bruitée (aucun compte requis)

Utilise FakeManilaV2 — un simulateur local qui reproduit le comportement d'un véritable appareil quantique IBM, y compris ses caractéristiques de bruit. Le circuit doit d'abord être transpilé (adapté) au jeu de portes et à la connectivité des qubits de l'appareil.

from qiskit.primitives import BackendSamplerV2
from qiskit_ibm_runtime.fake_provider import FakeManilaV2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

backend = FakeManilaV2()
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

result = BackendSamplerV2(backend=backend).run([isa_qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
counts

plot_histogram(counts)

Option 3 : Matériel quantique réel

Nécessite un compte IBM Quantum gratuit. Pour en créer un :

1. Inscris-toi sur quantum.cloud.ibm.com/registration — aucune carte de crédit requise pendant les 30 premiers jours

2. Connecte-toi sur quantum.cloud.ibm.com et sélectionne la région us-east (requise pour le forfait Open gratuit)

3. Crée une instance (forfait Open gratuit) sur Instances si tu n'en as pas encore

4. Crée une clé API sur quantum.cloud.ibm.com (ou sur cloud.ibm.com/iam/apikeys)

5. Copie ton CRN (Cloud Resource Name) depuis ta page Instances

Ensuite, si tu n'as pas encore enregistré tes identifiants ici, exécute la cellule ci-dessous. Remplace <your-api-key> par la clé API de l'étape 4, et <your-crn> par le CRN de l'étape 5. Tant que tu ne l'as pas fait, la cellule n'enregistre rien, donc exécuter toutes les cellules ne peut jamais écraser un compte que tu as enregistré auparavant.

from qiskit_ibm_runtime import QiskitRuntimeService

token = "<your-api-key>"
instance = "<your-crn>"

if token.startswith("<") or instance.startswith("<"):
    print("Paste your API key and CRN above first; nothing was saved.")
else:
    QiskitRuntimeService.save_account(
        channel="ibm_quantum_platform",
        token=token,
        instance=instance,
        set_as_default=True,
        overwrite=True,
    )
    print("Account saved.")

Remarque : Les tâches sur du matériel réel peuvent prendre un certain temps selon l'attente dans la file. Si la cellule est toujours en cours d'exécution, tu peux vérifier l'état de ta tâche et consulter les résultats sur quantum.cloud.ibm.com/workloads.

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)
print(f"Running on {backend.name}")

pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
isa_qc = pm.run(qc)

result = SamplerV2(mode=backend).run([isa_qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
counts

plot_histogram(counts)

Et ensuite ?

• Tutoriels — guides pas à pas sur les algorithmes, l'atténuation des erreurs, la transpilation et bien plus encore

• Guides — documentation de référence sur l'exécution de circuits, les primitives et Qiskit Runtime

• Cours — parcours d'apprentissage structurés, des bases du quantique au calcul à l'échelle utilitaire

• Modules — modules conceptuels approfondis en informatique et mécanique quantique