Cirq - Calcul quantique avec Python

Cirq est le framework open-source de Google Quantum AI pour concevoir, simuler et exécuter des circuits quantiques sur des ordinateurs quantiques et des simulateurs.

Installation

uv pip install cirq

Pour l'intégration matérielle :

# Google Quantum Engine
uv pip install cirq-google

# IonQ
uv pip install cirq-ionq

# AQT (Alpine Quantum Technologies)
uv pip install cirq-aqt

# Pasqal
uv pip install cirq-pasqal

# Azure Quantum
uv pip install azure-quantum cirq

Démarrage rapide

Circuit basique

import cirq
import numpy as np

# Create qubits
q0, q1 = cirq.LineQubit.range(2)

# Build circuit
circuit = cirq.Circuit(
    cirq.H(q0),              # Hadamard on q0
    cirq.CNOT(q0, q1),       # CNOT with q0 control, q1 target
    cirq.measure(q0, q1, key='result')
)

print(circuit)

# Simulate
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=1000)

# Display results
print(result.histogram(key='result'))

Circuit paramétré

import sympy

# Define symbolic parameter
theta = sympy.Symbol('theta')

# Create parameterized circuit
circuit = cirq.Circuit(
    cirq.ry(theta)(q0),
    cirq.measure(q0, key='m')
)

# Sweep over parameter values
sweep = cirq.Linspace('theta', start=0, stop=2*np.pi, length=20)
results = simulator.run_sweep(circuit, params=sweep, repetitions=1000)

# Process results
for params, result in zip(sweep, results):
    theta_val = params['theta']
    counts = result.histogram(key='m')
    print(f"θ={theta_val:.2f}: {counts}")

Capacités principales

Construction de circuits

Pour des informations complètes sur la construction de circuits quantiques, y compris les qubits, les portes, les opérations, les portes personnalisées et les motifs de circuits, consultez :

references/building.md - Guide complet de la construction de circuits

Sujets courants :

Types de qubits (GridQubit, LineQubit, NamedQubit)
Portes à un et deux qubits
Portes paramétrées et opérations
Décomposition de portes personnalisées
Organisation des circuits avec des moments
Motifs de circuits standard (états de Bell, GHZ, QFT)
Importation/exportation (OpenQASM, JSON)
Travail avec les qudits et observables

Simulation

Pour des informations détaillées sur la simulation de circuits quantiques, y compris la simulation exacte, la simulation bruitée, les balayages de paramètres et la Machine Virtuelle Quantique, consultez :

references/simulation.md - Guide complet de la simulation quantique

Sujets courants :

Simulation exacte (vecteur d'état, matrice densité)
Échantillonnage et mesures
Balayages de paramètres (paramètres simples et multiples)
Simulation bruitée
Histogrammes d'états et visualisation
Machine Virtuelle Quantique (QVM)
Valeurs d'espérance et observables
Optimisation des performances

Transformation de circuits

Pour des informations sur l'optimisation, la compilation et la manipulation de circuits quantiques, consultez :

references/transformation.md - Guide complet des transformations de circuits

Sujets courants :

Framework transformateur
Décomposition de portes
Optimisation de circuits (fusion de portes, éjection de portes Z, suppression d'opérations négligeables)
Compilation de circuits pour le matériel
Routage de qubits et insertion de SWAP
Transformateurs personnalisés
Pipelines de transformation

Intégration matérielle

Pour des informations sur l'exécution de circuits sur du matériel quantique réel de divers fournisseurs, consultez :

references/hardware.md - Guide complet de l'intégration matérielle

Fournisseurs supportés :

Google Quantum AI (cirq-google) - Processeurs Sycamore, Weber
IonQ (cirq-ionq) - Ordinateurs quantiques à ions piégés
Azure Quantum (azure-quantum) - Backends IonQ et Honeywell
AQT (cirq-aqt) - Alpine Quantum Technologies
Pasqal (cirq-pasqal) - Ordinateurs quantiques à atomes neutres

Les sujets incluent la représentation des appareils, la sélection de qubits, l'authentification, la gestion des travaux et l'optimisation de circuits pour le matériel.

Modélisation du bruit

Pour des informations sur la modélisation du bruit, la simulation bruitée, la caractérisation et l'atténuation des erreurs, consultez :

references/noise.md - Guide complet de la modélisation du bruit

Sujets courants :

Canaux de bruit (dépolarisation, amortissement d'amplitude, amortissement de phase)
Modèles de bruit (constant, spécifique à la porte, spécifique au qubit, thermique)
Ajout de bruit aux circuits
Bruit de lecture
Caractérisation du bruit (benchmarking randomisé, XEB)
Visualisation du bruit (cartes thermiques)
Techniques d'atténuation d'erreurs

Expériences quantiques

Pour des informations sur la conception d'expériences, les balayages de paramètres, la collecte de données et l'utilisation du framework ReCirq, consultez :

references/experiments.md - Guide complet des expériences quantiques

Sujets courants :

Motifs de conception d'expériences
Balayages de paramètres et collecte de données
Structure du framework ReCirq
Algorithmes courants (VQE, QAOA, QPE)
Analyse et visualisation des données
Analyse statistique et estimation de fidélité
Collecte de données parallèle

Motifs courants

Modèle d'algorithme variationnel

import scipy.optimize

def variational_algorithm(ansatz, cost_function, initial_params):
    """Template for variational quantum algorithms."""

    def objective(params):
        circuit = ansatz(params)
        simulator = cirq.Simulator()
        result = simulator.simulate(circuit)
        return cost_function(result)

    # Optimize
    result = scipy.optimize.minimize(
        objective,
        initial_params,
        method='COBYLA'
    )

    return result

# Define ansatz
def my_ansatz(params):
    q = cirq.LineQubit(0)
    return cirq.Circuit(
        cirq.ry(params[0])(q),
        cirq.rz(params[1])(q)
    )

# Define cost function
def my_cost(result):
    state = result.final_state_vector
    # Calculate cost based on state
    return np.real(state[0])

# Run optimization
result = variational_algorithm(my_ansatz, my_cost, [0.0, 0.0])

Modèle d'exécution matérielle

def run_on_hardware(circuit, provider='google', device_name='weber', repetitions=1000):
    """Template for running on quantum hardware."""

    if provider == 'google':
        import cirq_google
        engine = cirq_google.get_engine()
        processor = engine.get_processor(device_name)
        job = processor.run(circuit, repetitions=repetitions)
        return job.results()[0]

    elif provider == 'ionq':
        import cirq_ionq
        service = cirq_ionq.Service()
        result = service.run(circuit, repetitions=repetitions, target='qpu')
        return result

    elif provider == 'azure':
        from azure.quantum.cirq import AzureQuantumService
        # Setup workspace...
        service = AzureQuantumService(workspace)
        result = service.run(circuit, repetitions=repetitions, target='ionq.qpu')
        return result

    else:
        raise ValueError(f"Unknown provider: {provider}")

Modèle d'étude du bruit

def noise_comparison_study(circuit, noise_levels):
    """Compare circuit performance at different noise levels."""

    results = {}

    for noise_level in noise_levels:
        # Create noisy circuit
        noisy_circuit = circuit.with_noise(cirq.depolarize(p=noise_level))

        # Simulate
        simulator = cirq.DensityMatrixSimulator()
        result = simulator.run(noisy_circuit, repetitions=1000)

        # Analyze
        results[noise_level] = {
            'histogram': result.histogram(key='result'),
            'dominant_state': max(
                result.histogram(key='result').items(),
                key=lambda x: x[1]
            )
        }

    return results

# Run study
noise_levels = [0.0, 0.001, 0.01, 0.05, 0.1]
results = noise_comparison_study(circuit, noise_levels)

Bonnes pratiques

Conception de circuits
- Utiliser les types de qubits appropriés pour votre topologie
- Garder les circuits modulaires et réutilisables
- Étiqueter les mesures avec des clés descriptives
- Valider les circuits par rapport aux contraintes de l'appareil avant l'exécution
Simulation
- Utiliser la simulation par vecteur d'état pour les états purs (plus efficace)
- Utiliser la simulation par matrice densité uniquement si nécessaire (états mixtes, bruit)
- Exploiter les balayages de paramètres au lieu des exécutions individuelles
- Surveiller l'utilisation de la mémoire pour les grands systèmes (2^n augmente rapidement)
Exécution matérielle
- Toujours tester sur des simulateurs d'abord
- Sélectionner les meilleurs qubits à l'aide de données d'étalonnage
- Optimiser les circuits pour l'ensemble de portes matériel cible
- Implémenter l'atténuation d'erreurs pour les exécutions en production
- Stocker immédiatement les résultats matériels coûteux
Optimisation des circuits
- Commencer par les transformateurs intégrés de haut niveau
- Chaîner plusieurs optimisations en séquence
- Suivre la réduction de la profondeur et du nombre de portes
- Valider la correction après la transformation
Modélisation du bruit
- Utiliser des modèles de bruit réalistes à partir de données d'étalonnage
- Inclure toutes les sources d'erreur (portes, décohérence, lecture)
- Caractériser avant d'atténuer
- Garder les circuits peu profonds pour minimiser l'accumulation de bruit
Expériences
- Structurer les expériences avec une séparation claire (génération de données, collecte, analyse)
- Utiliser les motifs ReCirq pour la reproductibilité
- Sauvegarder les résultats intermédiaires fréquemment
- Paralléliser les tâches indépendantes
- Documenter complètement avec des métadonnées

Ressources supplémentaires

Documentation officielle : https://quantumai.google/cirq
Référence API : https://quantumai.google/reference/python/cirq
Tutoriels : https://quantumai.google/cirq/tutorials
Exemples : https://github.com/quantumlib/Cirq/tree/master/examples
ReCirq : https://github.com/quantumlib/ReCirq

Problèmes courants

Circuit trop profond pour le matériel :

Utiliser les transformateurs d'optimisation de circuits pour réduire la profondeur
Consulter transformation.md pour les techniques d'optimisation

Problèmes de mémoire avec la simulation :

Passer du simulateur de matrice densité au simulateur de vecteur d'état
Réduire le nombre de qubits ou utiliser le simulateur stabilisateur pour les circuits Clifford

Erreurs de validation de l'appareil :

Vérifier la connectivité des qubits avec device.metadata.nx_graph
Décomposer les portes à l'ensemble de portes natif de l'appareil
Consulter hardware.md pour la compilation spécifique à l'appareil

Simulation bruitée trop lente :

La simulation par matrice densité est O(2^2n) - envisager de réduire les qubits
Utiliser les modèles de bruit sélectivement sur les opérations critiques uniquement
Consulter simulation.md pour l'optimisation des performances

Cirq - Calcul quantique avec Python

Installation

Démarrage rapide

Circuit basique

Circuit paramétré

Capacités principales

Construction de circuits

Simulation

Transformation de circuits

Intégration matérielle

Modélisation du bruit

Expériences quantiques

Motifs courants

Modèle d'algorithme variationnel

Modèle d'exécution matérielle

Modèle d'étude du bruit

Bonnes pratiques

Ressources supplémentaires

Problèmes courants

Skills similaires