科研 Skill
谷歌量子计算框架
cirq
Builds noise-aware quantum circuits for Google Quantum AI hardware and runs characterization experiments. Use for Google-hardware targeting; use qiskit for IBM or pennylane for differentiable ML.
SKILL.md
Cirq - Quantum Computing with Python
Cirq is Google Quantum AI's open-source framework for designing, simulating, and running quantum circuits on quantum computers and simulators.
When to Use This Skill
Use this skill when:
- Building, simulating, or optimizing NISQ circuits in Python
- Running jobs on Google Quantum AI processors (via
cirq-google) or partner backends (IonQ, Azure Quantum, AQT, Pasqal) - Modeling noise, compiling to hardware gatesets, or designing characterization experiments
- Using parameter sweeps, transformers, or the ReCirq experiment patterns
For IBM hardware use qiskit; for quantum ML with autodiff use pennylane; for physics simulations use qutip.
Installation
Requires Python 3.11+. Current stable release: 1.6.1 (August 2025). Vendor packages share the same version number.
uv pip install "cirq==1.6.1"
For hardware integration (pin matching versions for reproducibility):
# Google Quantum Engine (requires approved GCP project access)
uv pip install "cirq-google==1.6.1"
# IonQ
uv pip install "cirq-ionq==1.6.1"
# AQT (Alpine Quantum Technologies)
uv pip install "cirq-aqt==1.6.1"
# Pasqal
uv pip install "cirq-pasqal==1.6.1"
# Azure Quantum (IonQ, Honeywell/Quantinuum backends)
uv pip install "azure-quantum[cirq]"
For latest features during development, omit version pins; for production or hardware runs, pin all packages to the same Cirq release.
Quick Start
Basic Circuit
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'))
Parameterized Circuit
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}")
Core Capabilities
Circuit Building
For comprehensive information about building quantum circuits, including qubits, gates, operations, custom gates, and circuit patterns, see:
- references/building.md - Complete guide to circuit construction
Common topics:
- Qubit types (GridQubit, LineQubit, NamedQubit)
- Single and two-qubit gates
- Parameterized gates and operations
- Custom gate decomposition
- Circuit organization with moments
- Standard circuit patterns (Bell states, GHZ, QFT)
- Import/export (OpenQASM, JSON)
- Working with qudits and observables
Simulation
For detailed information about simulating quantum circuits, including exact simulation, noisy simulation, parameter sweeps, and the Quantum Virtual Machine, see:
- references/simulation.md - Complete guide to quantum simulation
Common topics:
- Exact simulation (state vector, density matrix)
- Sampling and measurements
- Parameter sweeps (single and multiple parameters)
- Noisy simulation
- State histograms and visualization
- Quantum Virtual Machine (QVM)
- Expectation values and observables
- Performance optimization
Circuit Transformation
For information about optimizing, compiling, and manipulating quantum circuits, see:
- references/transformation.md - Complete guide to circuit transformations
Common topics:
- Transformer framework
- Gate decomposition
- Circuit optimization (merge gates, eject Z gates, drop negligible operations)
- Circuit compilation for hardware
- Qubit routing and SWAP insertion
- Custom transformers
- Transformation pipelines
Hardware Integration
For information about running circuits on real quantum hardware from various providers, see:
- references/hardware.md - Complete guide to hardware integration
Supported providers:
- Google Quantum AI (
cirq-google) — Sycamore, Weber, Willow processors via Quantum Engine (restricted access; requires approved GCP project) - IonQ (
cirq-ionq) — trapped-ion QPUs and simulators - Azure Quantum (
azure-quantum[cirq]) — IonQ and Honeywell/Quantinuum backends - AQT (
cirq-aqt) — Alpine Quantum Technologies - Pasqal (
cirq-pasqal) — neutral-atom devices
Topics include device representation, qubit selection, authentication, job management, and circuit optimization for hardware. See Access and authentication for Google Cloud setup.
Noise Modeling
For information about modeling noise, noisy simulation, characterization, and error mitigation, see:
- references/noise.md - Complete guide to noise modeling
Common topics:
- Noise channels (depolarizing, amplitude damping, phase damping)
- Noise models (constant, gate-specific, qubit-specific, thermal)
- Adding noise to circuits
- Readout noise
- Noise characterization (randomized benchmarking, XEB)
- Noise visualization (heatmaps)
- Error mitigation techniques
Quantum Experiments
For information about designing experiments, parameter sweeps, data collection, and using the ReCirq framework, see:
- references/experiments.md - Complete guide to quantum experiments
Common topics:
- Experiment design patterns
- Parameter sweeps and data collection
- ReCirq framework structure
- Common algorithms (VQE, QAOA, QPE)
- Data analysis and visualization
- Statistical analysis and fidelity estimation
- Parallel data collection
Common Patterns
Variational Algorithm Template
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])
Hardware Execution Template
import os
def run_on_hardware(circuit, provider='google', processor_id=None, repetitions=1000):
"""Template for running on quantum hardware."""
if provider == 'google':
import cirq_google as cg
project_id = os.environ['GOOGLE_CLOUD_PROJECT']
engine = cg.Engine(project_id=project_id)
# List available processors: engine.list_processors()
processor_id = processor_id or 'weber' # use your assigned processor_id
sampler = engine.get_sampler(processor_id=processor_id)
return sampler.run(circuit, repetitions=repetitions)
elif provider == 'ionq':
import cirq_ionq as ionq
# Requires IONQ_API_KEY in environment
service = ionq.Service()
return service.run(circuit, repetitions=repetitions, target='qpu')
elif provider == 'azure':
from azure.quantum.cirq import AzureQuantumService
service = AzureQuantumService(
resource_id=os.environ['AZURE_QUANTUM_RESOURCE_ID'],
location=os.environ['AZURE_QUANTUM_LOCATION'],
)
return service.run(circuit, repetitions=repetitions, target='ionq.qpu')
else:
raise ValueError(f"Unknown provider: {provider}")
Noise Study Template
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)
Best Practices
-
Circuit Design
- Use appropriate qubit types for your topology
- Keep circuits modular and reusable
- Label measurements with descriptive keys
- Validate circuits against device constraints before execution
-
Simulation
- Use state vector simulation for pure states (more efficient)
- Use density matrix simulation only when needed (mixed states, noise)
- Leverage parameter sweeps instead of individual runs
- Monitor memory usage for large systems (2^n grows quickly)
-
Hardware Execution
- Always test on simulators first
- Select best qubits using calibration data
- Optimize circuits for target hardware gateset
- Implement error mitigation for production runs
- Store expensive hardware results immediately
-
Circuit Optimization
- Start with high-level built-in transformers
- Chain multiple optimizations in sequence
- Track depth and gate count reduction
- Validate correctness after transformation
-
Noise Modeling
- Use realistic noise models from calibration data
- Include all error sources (gate, decoherence, readout)
- Characterize before mitigating
- Keep circuits shallow to minimize noise accumulation
-
Experiments
- Structure experiments with clear separation (data generation, collection, analysis)
- Use ReCirq patterns for reproducibility
- Save intermediate results frequently
- Parallelize independent tasks
- Document thoroughly with metadata
Additional Resources
- Official Documentation: https://quantumai.google/cirq
- API Reference: https://quantumai.google/reference/python/cirq
- Tutorials: https://quantumai.google/cirq/tutorials
- Examples: https://github.com/quantumlib/Cirq/tree/main/examples
- Version policy: https://quantumai.google/cirq/dev/versions
- ReCirq: https://github.com/quantumlib/ReCirq
Common Issues
Circuit too deep for hardware:
- Use circuit optimization transformers to reduce depth
- See
transformation.mdfor optimization techniques
Memory issues with simulation:
- Switch from density matrix to state vector simulator
- Reduce number of qubits or use stabilizer simulator for Clifford circuits
Device validation errors:
- Check qubit connectivity with device.metadata.nx_graph
- Decompose gates to device-native gateset
- See
hardware.mdfor device-specific compilation
Noisy simulation too slow:
- Density matrix simulation is O(2^2n) - consider reducing qubits
- Use noise models selectively on critical operations only
- See
simulation.mdfor performance optimization
示例提示词
我想用Cirq设计一个抗噪声量子线路并在谷歌硬件上做表征实验。
所属插件
安装该插件会一并获得同领域的 22 个 Skill / MCP。
同插件的其他科研 Skill
- 天文星表检索Queries astronomical archives (Gaia, SDSS, VizieR, MAST, NED, SIMBAD) via astroquery/TAP/ADQL and cross-matches results. Use when sourcing or combining survey data by position.
- 天文光谱分析Reduces 1D astronomical spectra with specutils: continuum normalization, line fitting, redshift/radial-velocity measurement, equivalent widths. Use for spectral classification or velocity work.
- 天文观测数据分析Runs applied astronomy pipelines with astropy/astroquery: catalog cross-matching, Gaia/SIMBAD queries, aperture photometry, CMB power spectra. Use for end-to-end data-analysis workflows.
- Astropy天文数据处理Covers core Astropy APIs for units, coordinates, FITS I/O, tables, time systems, WCS, and cosmology. Use as the API reference, before reaching for applied workflows.
- 有限元法求解偏微分方程Solves PDEs with finite elements using FEniCS/dolfinx: weak forms, gmsh meshing, Poisson/elasticity problems, boundary conditions, ParaView export. Use for continuum-physics simulation.
- 计算流体力学模拟Runs pseudospectral CFD simulations in Python: Navier-Stokes, shallow water, stratified flows with FFT-based solvers. Use for turbulence, vortex dynamics, or geophysical flow simulation.
- LAMMPS经典分子动力学Runs classical molecular dynamics with LAMMPS: force field selection, NVT/NPT ensembles, RDF/MSD post-processing, OVITO visualization. Use for atomistic materials or molecular simulation.
- 三维科学可视化Creates 3D scientific visualizations with Mayavi: vector fields, isosurfaces, volume rendering, animated 3D plots. Use for visualizing volumetric or vector-field physics data.
- 蒙特卡洛物理模拟Simulates physical systems with Monte Carlo methods: statistical integration, MCMC sampling, the Ising model, error estimation. Use for stochastic physics simulation.
- 地震学数据处理Analyzes seismological data with ObsPy: FDSN waveform download, response removal, phase picking, moment tensor inversion. Use for earthquake and seismic-waveform analysis.
- 粒子图像测速分析Extracts velocity fields from PIV image pairs with OpenPIV: cross-correlation, vector validation, vorticity/strain-rate statistics. Use for experimental fluid-flow measurement.
- 量子机器学习框架Trains quantum circuits with autodiff across IBM/Google/Rigetti/IonQ devices: VQE, QAOA, hybrid models with PyTorch/JAX. Use for gradient-based variational quantum algorithms.
- 恒星测光分析Performs PSF and aperture photometry with photutils: source detection, PSF fitting, background estimation, multi-epoch light curves. Use for precision stellar photometry beyond one aperture sum.
- 物理信息神经网络Builds physics-informed neural networks, neural ODEs, and data-driven force fields with PyTorch, DeepXDE, torchdiffeq. Use for ML-based physics simulation and surrogate modeling.
- IBM量子计算框架Runs IBM Quantum workflows end to end: Runtime primitives, transpilation, hardware backend selection, error mitigation. Use when targeting IBM Quantum hardware or Runtime.
- Qiskit量子线路实验Implements Qiskit algorithms: circuit construction, VQE/QAOA workflows, noise-model simulation, statevector-vs-shot comparisons. Use for algorithm design and local simulation.
- 开放量子系统模拟Simulates open quantum systems with QuTiP: master equations, Lindblad dynamics, decoherence, cavity QED. Use for open-system physics, not circuit-based quantum computing.
- SciPy数值计算工具Solves ODEs/PDEs, runs FFT analysis, optimization, and sparse linear algebra with SciPy for physics problems. Use as the general-purpose numerical-computing toolkit.
- SymPy符号计算Performs symbolic computation for physics with SymPy: algebra, calculus, Lagrangian mechanics, quantum operators, code generation. Use for exact derivations, not numerical solving.
- 物理量纲与不确定度传播Tracks physical units and propagates measurement uncertainty with pint/uncertainties: GUM budgets, Monte Carlo propagation, dimensionless-group checks. Use to sanity-check a result or unit.
- 多维标注数组NetCDF分析Analyzes labeled multi-dimensional arrays with xarray: NetCDF/HDF5 I/O, lazy Dask loading, rechunking, Zarr stores, CF conventions. Use for gridded scientific data handling.
常见问题
谷歌量子计算框架能做什么?
Builds noise-aware quantum circuits for Google Quantum AI hardware and runs characterization experiments. Use for Google-hardware targeting; use qiskit for IBM or pennylane for differentiable ML。
如何安装谷歌量子计算框架?
在科搭 Codar 左侧点击「插件」,在「组件」页签搜索「谷歌量子计算框架」并安装;在 Claude Code 或 Codex 中可以发送本页的安装提示词,或下载 Skill 包后解压到 ~/.claude/skills 或 ~/.codex/skills。
谷歌量子计算框架需要哪些权限?
该科研 Skill没有声明额外权限;执行具体操作时仍由 Agent 按自身规则请求确认。
谷歌量子计算框架经过官方审核吗?
是。SpeedSkills 收录的每个版本都会记录内容摘要与权限声明,当前版本已通过安全审核。