Skip to main content
CodeSpeedTest
Languages
Start TypingJump into a test — pick any languageAdaptive TrainingUnlock chars as you master themPractice DrillsFocused sessions targeting weak spotsDaily ChallengesNew coding challenges every dayRace ModeCompete against others in real timeAI OpponentRace against an AI at your WPM levelTournamentsLive coding speed tournamentsArcade GamesZType, Overkill Survival, Glyphica & moreGamificationXP, coins, badges & quests
LeaderboardGlobal rankings for every languageCertificatesEarn verifiable Bronze / Silver / Gold certsActivityDaily streaks & historical analyticsProfileYour stats, badges & achievements
Browse Languages500+ languages with real code examplesBlogTips, guides & deep divesFree ToolsWPM calculator, typing speed report & moreFAQCommon questions answeredGetting StartedNew to CodeSpeedTest?AboutOur story & missionSupportGet help — Pro users get priorityContactGet in touch with the team
Pricing
  1. Home
  2. /
  3. Learn
  4. /
  5. Cirq

Learn Cirq - 10 Code Examples & CST Typing Practice Test

Cirq is an open-source Python framework for quantum computing, developed by Google, focused on designing, simulating, and running quantum circuits on NISQ (Noisy Intermediate-Scale Quantum) devices.

View all 10 Cirq code examples →
Cirq Simple Quantum CircuitCirq Single Qubit RotationCirq Bell StateCirq GHZ StateCirq Random CircuitCirq Quantum Fourier TransformCirq Parameterized GateCirq Controlled GatesCirq Swap Gate ExampleCirq Measurement in Different Basis

Learn CIRQ with Real Code Examples

Updated Nov 25, 2025

Explain

Cirq allows developers to create and manipulate quantum circuits at the gate level.

It provides simulation tools as well as interfaces for running circuits on Google quantum hardware.

Cirq emphasizes control over noise, pulse-level operations, and optimization of circuits for near-term quantum devices.

Core Features

Quantum circuit creation using `cirq.Circuit`

Qubit definition with `cirq.GridQubit` or `cirq.LineQubit`

Gate operations like `X`, `H`, `CNOT`, and custom gates

Simulation via `cirq.Simulator` with or without noise

Measurement and sampling analysis tools

Basic Concepts Overview

Qubit: fundamental quantum information unit

Circuit: sequence of quantum gates applied to qubits

Gate: quantum operation applied to qubits

Moment: collection of gates applied simultaneously

Simulator/Backend: environment to run circuits (classical or quantum hardware)

Project Structure

Notebooks/ - experiments and tutorials

Circuits/ - custom quantum circuit definitions

Simulations/ - results from simulator or hardware

Data/ - measurement and analysis results

Scripts/ - utility and automation scripts

Building Workflow

Import Cirq and define qubits

Create gates and build a quantum circuit

Group gates into moments for scheduling

Simulate circuit using `cirq.Simulator`

Measure qubits and analyze results

Difficulty Use Cases

Beginner: simulate basic gates and entanglement

Intermediate: implement small quantum algorithms (Grover, Bernstein-Vazirani)

Advanced: optimize circuits for noise mitigation

Expert: pulse-level and error-aware programming

Enterprise: integrate with classical pipelines for hybrid algorithms

Comparisons

Cirq vs Qiskit: Cirq targets Google hardware, Qiskit targets IBM devices

Cirq vs Pennylane: Cirq focuses on NISQ circuits, Pennylane emphasizes quantum ML

Cirq vs Braket: Braket supports multi-cloud, Cirq is Google-focused

Cirq vs PyQuil: PyQuil is for Rigetti hardware, Cirq is Google-focused

Cirq vs ProjectQ: Cirq is more NISQ-oriented with gate-level control

Versioning Timeline

2017 - Initial Cirq development by Google Research

2018 - Cirq open-sourced

2019 - Integration with Google Quantum Engine

2020 - Noise modeling and optimizers introduced

2023 - Enhanced hybrid ML and pulse-level controls

Glossary

Qubit: fundamental quantum information unit

Gate: quantum operation applied to qubits

Circuit: sequence of gates applied to qubits

Moment: collection of gates applied simultaneously

Simulator: classical tool to emulate quantum circuit behavior

Installation Setup

Install Python 3.8+

Install Cirq via `pip install cirq`

Optional: Install visualization libraries (`matplotlib`, `cirq.contrib.qcircuit`)

Optional: Configure Google Quantum Engine access

Verify installation via `import cirq; print(cirq.__version__)`

Environment Setup

Install Python 3.8+

Install Cirq via pip

Optional: configure Google Quantum Engine API

Install visualization libraries if needed

Verify installation and run example circuits

Config Files

Optional cirq_config.json - backend and account settings

Notebooks/ - experiment and tutorial notebooks

Circuits/ - quantum circuit definitions

Simulations/ - simulation results

Scripts/ - utility and automation scripts

Cli Commands

cirq info

cirq simulator

cirq optimizer

cirq run

cirq google execute

Internationalization

Community contributions worldwide

Documentation primarily in English

Compatible with global research collaborations

Supports international quantum algorithm standards

Adopted in NISQ hardware experiments globally

Accessibility

Python-based cross-platform support

Open-source Apache 2.0 license

Supports educational, research, and enterprise use

Integrates with classical Python ecosystem

Accessible via Google Quantum Engine

Ui Styling

Jupyter notebooks for experiments

Matplotlib or Cirq contrib for circuit visualization

CLI outputs for execution status

Integration with dashboards for monitoring experiments

Optional GUI tools for circuit layout

State Management

Track circuit versions and parameters

Store measurement outcomes

Log simulation and hardware execution results

Maintain reproducible scripts and notebooks

Manage Google Quantum Engine job submissions

Data Management

Serialize measurement samples for analysis

Cache simulation results

Document circuits and gate sequences

Maintain reproducibility and experiment tracking

Organize datasets for benchmarking algorithms

Architecture

Python-based SDK for defining circuits and gates

Qubit abstractions (Grid, Line, NamedQubit) for layout control

Backend-agnostic execution via simulators or Google QPU access

Integration with optimization and noise modeling tools

Measurement results stored as samples or statevectors

Rendering Model

Python-based code for circuits and gates

Simulation with `cirq.Simulator` or real hardware execution

Measurement and sampling results visualization

Integration with classical and hybrid workflows

Backend access via Google Quantum Engine

Architectural Patterns

Modular library structure with circuits, qubits, gates, and optimizers

Separation of circuit definition, execution, and result analysis

Backend-agnostic simulation and hardware interfaces

Support for custom gate definitions and pulse-level control

Hybrid classical-quantum computation pipelines

Real World Architectures

Quantum optimization pipelines

Variational quantum circuits for machine learning

NISQ device benchmarking and noise characterization

Hybrid classical-quantum computation pipelines

Research experiments on Google Quantum Engine

Design Principles

Provide gate-level control for NISQ devices

Enable detailed simulation and noise-aware execution

Support both high-level algorithms and low-level circuits

Integrate with classical optimization and ML frameworks

Promote open-source community contributions

Scalability Guide

Use simulators for small circuits, hardware for larger experiments

Parallelize simulations where possible

Optimize circuits to reduce depth and qubit count

Batch multiple experiments for hybrid workflows

Monitor backend performance for queue management

Migration Guide

Update Cirq packages via pip

Check for API changes in new releases

Validate existing circuits on simulator

Update scripts and notebooks if needed

Ensure reproducible execution with upgraded version

Performance Notes

Simulation cost grows exponentially with number of qubits

Noise simulation slows down performance

Parallel simulation supported via multiprocessing

Gate optimization can improve execution efficiency

Circuit depth affects execution on real hardware

Security Notes

Keep cloud API tokens secure

Avoid unnecessary runs on paid quantum devices

Ensure reproducibility with fixed random seeds

Validate circuit logic before running on hardware

Use classical post-processing for sensitive computations

Monitoring Analytics

Monitor simulator or hardware job execution

Track measurement outcomes and statistics

Visualize circuit states and probabilities

Audit experiments and logs

Compare simulator and hardware results

Code Quality

Follow Python and Cirq coding best practices

Document circuits and algorithms

Maintain reproducibility for experiments

Simulate circuits before hardware execution

Optimize circuits for minimal depth and gate usage

Practical Examples

Simulate a Bell state circuit

Run Grover's search algorithm on a simulator

Implement variational quantum circuits for optimization

Test algorithms on Google Sycamore hardware

Visualize circuit diagrams and measurement results

Troubleshooting

Check qubit definitions and dimensions match

Ensure simulator or backend is properly instantiated

Validate gate compatibility with NISQ hardware

Debug circuit errors using simplified simulator runs

Check measurement results and correct indexing

Testing Guide

Simulate circuits locally before running on hardware

Use noise models to test algorithm robustness

Compare results between simulator and hardware

Visualize measurement distributions

Validate algorithm correctness step by step

Deployment Options

Run experiments on local simulator

Execute jobs on Google Quantum Engine

Test hybrid classical-quantum optimization pipelines

Batch multiple circuits for parallel execution

Integrate with ML workflows for hybrid tasks

Tools Ecosystem

Cirq core library for circuits and gates

Cirq Simulator for classical simulation

Cirq Google Engine interface for hardware execution

Cirq contrib modules for visualization

Cirq optimizers for circuit simplification

Integrations

Google Quantum Engine for real-device access

Python scientific libraries (NumPy, SciPy, Matplotlib)

Classical optimization frameworks

TensorFlow Quantum for hybrid ML pipelines

Jupyter notebooks for interactive experimentation

Productivity Tips

Start with local simulation before hardware execution

Visualize circuits to debug quickly

Modularize gates and subcircuits for reuse

Cache results for reproducibility

Use Cirq optimizers for circuit efficiency

Challenges

Handling noise on NISQ devices

Optimizing circuit depth and gate count

Scaling simulations to larger qubit numbers

Interpreting quantum measurement outcomes

Integrating quantum and classical computation

Learning Path

Learn basic Python programming

Understand quantum computing principles

Build quantum circuits using Cirq

Simulate circuits and test algorithms

Execute circuits on Google Quantum Engine and analyze results

Skill Improvement Plan

Week 1: Install Cirq and simulate basic circuits

Week 2: Implement standard algorithms (Grover, Deutsch-Jozsa)

Week 3: Explore noise modeling and optimizers

Week 4: Execute experiments on Google quantum hardware

Week 5: Integrate classical post-processing and hybrid pipelines

Interview Questions

What is Cirq and what are its main components?

Explain the difference between simulation and hardware execution

How do you define and run a quantum circuit in Cirq?

Describe noise-aware algorithm testing in Cirq

Compare Cirq with other quantum frameworks like Qiskit or Pennylane

Cheat Sheet

cirq.Circuit() = create new circuit

cirq.GridQubit(x, y) = define qubit at grid location

qc.append(cirq.H(q)) = apply Hadamard gate to qubit q

qc.append(cirq.CNOT(control, target)) = apply CNOT gate

simulator.run(circuit) = execute circuit on simulator

Books

Programming Quantum Computers with Cirq

Practical Quantum Computing with Cirq

Variational Quantum Algorithms with Cirq

Quantum Circuit Design and Optimization

Cirq Textbook and Tutorial Collection

Tutorials

Cirq official tutorials

Quantum circuits and algorithm examples

Variational algorithms with Cirq

Noise modeling and optimization pipelines

Integration with TensorFlow Quantum for ML experiments

Official Docs

https://quantumai.google/cirq

https://github.com/quantumlib/Cirq

Community Links

Cirq GitHub repository

Cirq Slack and Discord channels

Google Quantum Community

Quantum StackExchange

Academic Cirq workshops and tutorials

Community Support

Cirq GitHub repository

Cirq Slack and Discord channels

Google Quantum Community

Quantum StackExchange

Academic Cirq workshops and tutorials

Monetization

Quantum algorithm consulting

Education and training in quantum computing

Hybrid classical-quantum optimization solutions

Develop quantum machine learning pipelines

Research collaboration and publications

Future Roadmap

Support for additional NISQ hardware backends

Enhanced noise mitigation and error correction

Improved hybrid ML integration

Expanded visualization and debugging tools

Growing community tutorials and open-source contributions

When Not To Use

If targeting only IBM or Rigetti hardware

For classical-only computation problems

When high-level algorithm libraries are preferred

If Python workflow is not desired

For extremely large circuits beyond classical simulation

Final Summary

Cirq is a Python framework for designing, simulating, and executing quantum circuits, optimized for NISQ devices.

Supports gate-level control, noise modeling, and hardware execution.

Integrates with classical optimization and machine learning pipelines.

Visualization and simulation tools enable detailed analysis of quantum circuits.

Widely used in research, industry, and education for quantum algorithm development.

Faq

Is Cirq free?

Yes - open-source under Apache 2.0 license.

Which quantum devices does Cirq support?

Primarily Google Quantum processors and local simulators.

Can Cirq simulate quantum algorithms?

Yes - using `cirq.Simulator` with optional noise models.

Does Cirq support quantum machine learning?

Yes - integrates with TensorFlow Quantum for hybrid ML.

Can Cirq handle optimization problems?

Yes - through variational quantum circuits and classical optimization routines.

Code Sample Descriptions

1

Cirq Simple Quantum Circuit

import cirq

qubits = [cirq.GridQubit(0,0), cirq.GridQubit(0,1)]

circuit = cirq.Circuit()
circuit.append(cirq.H(qubits[0]))
circuit.append(cirq.CNOT(qubits[0],qubits[1]))
circuit.append(cirq.measure(*qubits,key='result'))

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

A minimal Cirq example creating a 2-qubit quantum circuit, applying Hadamard and CNOT gates, and simulating measurements.

Let’s Try →
2

Cirq Single Qubit Rotation

import cirq

q = cirq.GridQubit(0,0)
circuit = cirq.Circuit(cirq.rx(1.5708)(q), cirq.measure(q,key='m'))
sim = cirq.Simulator()
result = sim.run(circuit,repetitions=500)
print(result)

Applies a rotation gate to a single qubit and measures it.

Let’s Try →
3

Cirq Bell State

import cirq

q0,q1 = cirq.GridQubit(0,0),cirq.GridQubit(0,1)
circuit = cirq.Circuit(cirq.H(q0), cirq.CNOT(q0,q1), cirq.measure(q0,q1,key='result'))
sim = cirq.Simulator()
result = sim.run(circuit,repetitions=1000)
print(result)

Generates a Bell state and measures both qubits.

Let’s Try →
4

Cirq GHZ State

import cirq

q = [cirq.GridQubit(0,i) for i in range(3)]
circuit = cirq.Circuit(cirq.H(q[0]), cirq.CNOT(q[0],q[1]), cirq.CNOT(q[0],q[2]), cirq.measure(*q,key='result'))
sim = cirq.Simulator()
result = sim.run(circuit,repetitions=1000)
print(result)

Creates a 3-qubit GHZ state and measures all qubits.

Let’s Try →
5

Cirq Random Circuit

import cirq

q = [cirq.GridQubit(0,0),cirq.GridQubit(0,1)]
circuit = cirq.testing.random_circuit(qubits=q, n_moments=5, op_density=0.5)
sim = cirq.Simulator()
result = sim.run(circuit,repetitions=500)
print(circuit)
print(result)

Creates a random quantum circuit with 2 qubits.

Let’s Try →
6

Cirq Quantum Fourier Transform

import cirq

q = [cirq.GridQubit(0,i) for i in range(3)]
circuit = cirq.Circuit()
for i in range(3):
    circuit.append(cirq.H(q[i]))
    for j in range(i+1,3):
        circuit.append(cirq.CZ(q[j],q[i])**(1/2**(j-i)))
circuit.append(cirq.measure(*q,key='result'))
sim = cirq.Simulator()
result = sim.run(circuit,repetitions=500)
print(result)

Implements QFT on 3 qubits.

Let’s Try →
7

Cirq Parameterized Gate

import cirq
import sympy

q = cirq.GridQubit(0,0)
theta = sympy.Symbol('theta')
circuit = cirq.Circuit(cirq.rx(theta)(q), cirq.measure(q,key='m'))
sim = cirq.Simulator()
result = sim.run(circuit,{theta:1.57},repetitions=500)
print(result)

Uses a parameterized rotation gate on a qubit.

Let’s Try →
8

Cirq Controlled Gates

import cirq

q0,q1 = cirq.GridQubit(0,0),cirq.GridQubit(0,1)
circuit = cirq.Circuit(cirq.H(q0), cirq.CZ(q0,q1), cirq.measure(q0,q1,key='result'))
sim = cirq.Simulator()
result = sim.run(circuit,repetitions=500)
print(result)

Demonstrates a controlled-Z gate between two qubits.

Let’s Try →
9

Cirq Swap Gate Example

import cirq

q0,q1 = cirq.GridQubit(0,0),cirq.GridQubit(0,1)
circuit = cirq.Circuit(cirq.SWAP(q0,q1), cirq.measure(q0,q1,key='result'))
sim = cirq.Simulator()
result = sim.run(circuit,repetitions=500)
print(result)

Swaps two qubits and measures them.

Let’s Try →
10

Cirq Measurement in Different Basis

import cirq

q = cirq.GridQubit(0,0)
circuit = cirq.Circuit(cirq.H(q), cirq.measure(q,key='X_basis'), cirq.measure(q,key='Z_basis'))
sim = cirq.Simulator()
result = sim.run(circuit,repetitions=500)
print(result)

Measures a qubit in X and Z bases.

Let’s Try →

Frequently Asked Questions about Cirq

What is Cirq?

Cirq is an open-source Python framework for quantum computing, developed by Google, focused on designing, simulating, and running quantum circuits on NISQ (Noisy Intermediate-Scale Quantum) devices.

What are the primary use cases for Cirq?

Designing and simulating quantum circuits. Running algorithms on Google's quantum processors. Optimization and combinatorial problem solving. Quantum machine learning experiments. Noise-aware quantum algorithm development

What are the strengths of Cirq?

Strong support for NISQ device experimentation. Flexible and modular for custom gate definitions. Noise simulation and calibration tools. Open-source and well-documented. Supported by Google Research and growing community

What are the limitations of Cirq?

Primarily optimized for Google quantum hardware. Steeper learning curve for beginners compared to high-level frameworks. Limited pre-built algorithm libraries compared to Qiskit. Hardware availability constrained to Google's quantum processors. Classical simulation of large circuits is exponentially costly

How can I practice Cirq typing speed?

CodeSpeedTest offers 10+ real Cirq code examples for typing practice. You can measure your WPM, track accuracy, and improve your coding speed with guided exercises.

Learn Other Programming Languages

CReactPythonC++RustTypeScriptKotlinPHPJavaC#RubyMqlCqlN1qlCypherGremlinPartiqlHaskellElixirFsharpView all languages →
CodeSpeedTest

Improve your coding speed, code accuracy, and programming syntax WPM with practice sessions across 500+ programming languages.

Quick Links

HomeAboutFeaturesGetting StartedLanguages

Legal & Support

Pro ⚡ PricingContactPrivacy PolicyTerms of Service

Connect

CodeSpeedTest on GitHubCodeSpeedTest on TwitterEmail CodeSpeedTest

© 2026 CodeSpeedTest. All rights reserved.