qiskit

Par mkurman · zorai

Framework de calcul quantique IBM. À utiliser pour cibler le matériel IBM Quantum, travailler avec Qiskit Runtime pour des charges de travail en production, ou exploiter les outils d'optimisation IBM. Idéal pour l'exécution sur matériel IBM, la mitigation des erreurs quantiques et le calcul quantique en entreprise. Pour le matériel Google, utiliser cirq ; pour le ML quantique basé sur les gradients, utiliser pennylane ; pour les simulations de systèmes quantiques ouverts, utiliser qutip.

npx skills add https://github.com/mkurman/zorai --skill qiskit

Qiskit

Aperçu

Qiskit est le framework de calcul quantique open-source le plus populaire au monde avec 13M+ téléchargements. Construisez des circuits quantiques, optimisez pour le matériel, exécutez sur des simulateurs ou des ordinateurs quantiques réels, et analysez les résultats. Supporte IBM Quantum (systèmes 100+ qubits), IonQ, Amazon Braket et d'autres fournisseurs.

Caractéristiques clés :

  • Transpilation 83x plus rapide que les concurrents
  • 29 % moins de portes à deux qubits dans les circuits optimisés
  • Exécution agnostique du backend (simulateurs locaux ou matériel cloud)
  • Bibliothèques d'algorithmes complètes pour l'optimisation, la chimie et le ML

Démarrage rapide

Installation

uv pip install qiskit
uv pip install "qiskit[visualization]" matplotlib

Premier circuit

from qiskit import QuantumCircuit
from qiskit.primitives import StatevectorSampler

# Create Bell state (entangled qubits)
qc = QuantumCircuit(2)
qc.h(0)           # Hadamard on qubit 0
qc.cx(0, 1)       # CNOT from qubit 0 to 1
qc.measure_all()  # Measure both qubits

# Run locally
sampler = StatevectorSampler()
result = sampler.run([qc], shots=1024).result()
counts = result[0].data.meas.get_counts()
print(counts)  # {'00': ~512, '11': ~512}

Visualisation

from qiskit.visualization import plot_histogram

qc.draw('mpl')           # Circuit diagram
plot_histogram(counts)   # Results histogram

Capacités principales

1. Configuration et installation

Pour une installation détaillée, l'authentification et la configuration du compte IBM Quantum :

  • Voir references/setup.md

Sujets couverts :

  • Installation avec uv
  • Configuration de l'environnement Python
  • Configuration du compte IBM Quantum et du token API
  • Exécution locale vs cloud

2. Construction de circuits quantiques

Pour construire des circuits quantiques avec des portes, des mesures et de la composition :

  • Voir references/circuits.md

Sujets couverts :

  • Création de circuits avec QuantumCircuit
  • Portes à un qubit (H, X, Y, Z, rotations, portes de phase)
  • Portes multi-qubits (CNOT, SWAP, Toffoli)
  • Mesures et barrières
  • Composition de circuits et propriétés
  • Circuits paramétrés pour les algorithmes variationnels

3. Primitives (Sampler et Estimator)

Pour exécuter des circuits quantiques et calculer les résultats :

  • Voir references/primitives.md

Sujets couverts :

  • Sampler : Obtenir les mesures de chaînes de bits et les distributions de probabilité
  • Estimator : Calculer les valeurs d'espérance des observables
  • Interface V2 (StatevectorSampler, StatevectorEstimator)
  • Primitives IBM Quantum Runtime pour le matériel
  • Modes Sessions et Batch
  • Liaison des paramètres

4. Transpilation et optimisation

Pour optimiser les circuits et préparer l'exécution sur le matériel :

  • Voir references/transpilation.md

Sujets couverts :

  • Pourquoi la transpilation est nécessaire
  • Niveaux d'optimisation (0-3)
  • Six étapes de transpilation (init, layout, routing, translation, optimization, scheduling)
  • Fonctionnalités avancées (élision de permutation virtuelle, annulation de portes)
  • Paramètres courants (initial_layout, approximation_degree, seed)
  • Meilleures pratiques pour les circuits efficaces

5. Visualisation

Pour afficher les circuits, les résultats et les états quantiques :

  • Voir references/visualization.md

Sujets couverts :

  • Dessins de circuits (texte, matplotlib, LaTeX)
  • Histogrammes de résultats
  • Visualisation de l'état quantique (sphère de Bloch, state city, QSphere)
  • Topologie du backend et cartes d'erreurs
  • Personnalisation et style
  • Enregistrement de figures de qualité publication

6. Backends matériels

Pour exécuter sur des simulateurs et des ordinateurs quantiques réels :

  • Voir references/backends.md

Sujets couverts :

  • Backends IBM Quantum et authentification
  • Propriétés et statut du backend
  • Exécution sur du matériel réel avec les primitives Runtime
  • Gestion des jobs et mise en queue
  • Mode Session (algorithmes itératifs)
  • Mode Batch (jobs parallèles)
  • Simulateurs locaux (StatevectorSampler, Aer)
  • Fournisseurs tiers (IonQ, Amazon Braket)
  • Stratégies d'atténuation des erreurs

7. Workflow Qiskit Patterns

Pour implémenter le workflow de calcul quantique en quatre étapes :

  • Voir references/patterns.md

Sujets couverts :

  • Map : Traduire les problèmes en circuits quantiques
  • Optimize : Transpiler pour le matériel
  • Execute : Exécuter avec les primitives
  • Post-process : Extraire et analyser les résultats
  • Exemple VQE complet
  • Exécution Session vs Batch
  • Patterns de workflow courants

8. Algorithmes et applications quantiques

Pour implémenter des algorithmes quantiques spécifiques :

  • Voir references/algorithms.md

Sujets couverts :

  • Optimisation : VQE, QAOA, algorithme de Grover
  • Chimie : États fondamentaux moléculaires, états excités, Hamiltoniens
  • Machine Learning : Noyaux quantiques, VQC, QNN
  • Bibliothèques d'algorithmes : Qiskit Nature, Qiskit ML, Qiskit Optimization
  • Simulations de physique et benchmarking

Guide de décision du workflow

Si vous avez besoin de :

  • Installer Qiskit ou configurer le compte IBM Quantum → references/setup.md
  • Construire un nouveau circuit quantique → references/circuits.md
  • Comprendre les portes et les opérations de circuit → references/circuits.md
  • Exécuter les circuits et obtenir les mesures → references/primitives.md
  • Calculer les valeurs d'espérance → references/primitives.md
  • Optimiser les circuits pour le matériel → references/transpilation.md
  • Visualiser les circuits ou les résultats → references/visualization.md
  • Exécuter sur le matériel IBM Quantum → references/backends.md
  • Se connecter à des fournisseurs tiers → references/backends.md
  • Implémenter un workflow quantique de bout en bout → references/patterns.md
  • Construire un algorithme spécifique (VQE, QAOA, etc.) → references/algorithms.md
  • Résoudre des problèmes de chimie ou d'optimisation → references/algorithms.md

Meilleures pratiques

Workflow de développement

  1. Commencez par les simulateurs : Testez localement avant d'utiliser le matériel

    from qiskit.primitives import StatevectorSampler
sampler = StatevectorSampler()

  2. Toujours transpiler : Optimisez les circuits avant l'exécution

    from qiskit import transpile
qc_optimized = transpile(qc, backend=backend, optimization_level=3)

  3. Utiliser les primitives appropriées :

    • Sampler pour les chaînes de bits (algorithmes d'optimisation)
    • Estimator pour les valeurs d'espérance (chimie, physique)

  4. Choisir le mode d'exécution :

    • Session : Algorithmes itératifs (VQE, QAOA)
    • Batch : Jobs parallèles indépendants
    • Job unique : Expériences ponctuelles

Optimisation des performances

  • Utiliser optimization_level=3 pour la production
  • Minimiser les portes à deux qubits (source d'erreur majeure)
  • Tester avec des simulateurs bruyants avant le matériel
  • Enregistrer et réutiliser les circuits transpilés
  • Surveiller la convergence dans les algorithmes variationnels

Exécution sur le matériel

  • Vérifier le statut du backend avant soumission
  • Utiliser least_busy() pour les tests
  • Enregistrer les IDs de job pour récupération ultérieure
  • Appliquer l'atténuation d'erreurs (resilience_level)
  • Commencer avec moins de shots, augmenter pour les exécutions finales

Patterns courants

Pattern 1 : Exécution simple de circuit

from qiskit import QuantumCircuit, transpile
from qiskit.primitives import StatevectorSampler

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

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

Pattern 2 : Exécution sur le matériel avec transpilation

from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2 as Sampler
from qiskit import transpile

service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")

qc_optimized = transpile(qc, backend=backend, optimization_level=3)

sampler = Sampler(backend)
job = sampler.run([qc_optimized], shots=1024)
result = job.result()

Pattern 3 : Algorithme variationnel (VQE)

from qiskit_ibm_runtime import Session, EstimatorV2 as Estimator
from scipy.optimize import minimize

with Session(backend=backend) as session:
    estimator = Estimator(session=session)

    def cost_function(params):
        bound_qc = ansatz.assign_parameters(params)
        qc_isa = transpile(bound_qc, backend=backend)
        result = estimator.run([(qc_isa, hamiltonian)]).result()
        return result[0].data.evs

    result = minimize(cost_function, initial_params, method='COBYLA')

Ressources supplémentaires

Skills similaires

cirq
mkurman / zorai

Concevoir, simuler et exécuter des circuits quantiques avec Python via Cirq.

309
claude-api
anthropics / skills

Construire des applications LLM avec Claude via le SDK officiel adapté au langage.

146 960
eval-bootstrap
datadog-labs / agent-skills

Générer du code d'évaluation Python à partir de traces de production LLM Datadog.

126
ad-model-onboard
nvidia / skills

Automatiser l'intégration de modèles HuggingFace dans AutoDeploy avec tests et rapport.

1 033
pennylane
mkurman / zorai

Entraîner et optimiser des circuits quantiques hybrides avec différentiation automatique.

309