Cirq

Cirq is a community skill for designing and simulating quantum circuits using Google's Cirq framework, covering qubit operations, gate sequences, circuit construction, noise simulation, and execution on quantum hardware for quantum computing research.

What Is This?

Overview

Cirq provides patterns for building quantum computing applications in Python using Google's open source quantum framework. It covers qubit definition and placement on device topologies, quantum gate operations including single-qubit rotations and multi-qubit entangling gates, circuit construction with moment-based scheduling for parallel gate execution, noise model simulation that mimics real quantum hardware behavior, and integration with quantum hardware backends for running circuits on actual quantum processors. The skill enables researchers to prototype quantum algorithms and test them against realistic noise conditions before hardware execution, reducing costly hardware runs by validating logic in simulation first.

Who Should Use This

This skill serves quantum computing researchers implementing variational and error correction algorithms, developers building quantum applications that target Google quantum hardware, and students learning quantum programming through circuit-level construction. It is particularly useful for teams transitioning from theoretical algorithm design to practical hardware deployment.

Why Use It?

Problems It Solves

Quantum circuit design requires precise control over gate decomposition and qubit connectivity that generic math libraries do not provide. Simulating quantum circuits with realistic noise demands specialized density matrix and trajectory simulators. Mapping logical circuits to physical device topologies involves routing and scheduling constraints that must be handled before hardware execution. Comparing ideal and noisy simulation results requires matched interfaces for both backends.

Core Highlights

LineQubit and GridQubit classes define qubits with explicit device topology placement. Moment-based circuit construction groups gates into parallel execution layers automatically. Built-in simulators support both state vector and density matrix methods for noise analysis. Device specifications enforce hardware connectivity constraints during circuit construction.

How to Use It?

Basic Usage

import cirq
import numpy as np

q0, q1 = cirq.LineQubit.range(2)

circuit = cirq.Circuit([
    cirq.H(q0),
    cirq.CNOT(q0, q1),
    cirq.measure(q0, q1, key="result")
])
print(circuit)

simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=1000)
counts = result.histogram(key="result")
print(f"Measurement counts: {counts}")

sv_circuit = cirq.Circuit([
    cirq.H(q0),
    cirq.CNOT(q0, q1)
])
state = simulator.simulate(sv_circuit)
print(f"State vector: {np.round(state.final_state_vector, 3)}")

Real-World Examples

import cirq
import numpy as np

def create_qft_circuit(n_qubits: int
                       ) -> cirq.Circuit:
    qubits = cirq.LineQubit.range(n_qubits)
    ops = []
    for i in range(n_qubits):
        ops.append(cirq.H(qubits[i]))
        for j in range(i + 1, n_qubits):
            angle = np.pi / (2 ** (j - i))
            ops.append(
                cirq.CZPowGate(
                    exponent=angle / np.pi
                )(qubits[i], qubits[j]))
    return cirq.Circuit(ops)

def noisy_simulation(circuit: cirq.Circuit,
                     noise_level: float = 0.01,
                     shots: int = 1000) -> dict:
    noise_model = cirq.ConstantQubitNoiseModel(
        qubit_noise_gate=cirq.DepolarizingChannel(
            p=noise_level))
    noisy = cirq.Circuit()
    for moment in circuit:
        noisy.append(moment)
        for op in moment:
            for q in op.qubits:
                noisy.append(
                    cirq.DepolarizingChannel(
                        p=noise_level)(q))
    qubits = sorted(circuit.all_qubits())
    noisy.append(cirq.measure(*qubits,
                              key="m"))
    sim = cirq.DensityMatrixSimulator()
    result = sim.run(noisy, repetitions=shots)
    return result.histogram(key="m")

qft = create_qft_circuit(3)
print(qft)
counts = noisy_simulation(qft)
print(f"Noisy results: {counts}")

Advanced Tips

Use cirq.optimize_for_target_gateset to decompose circuits into gates supported by specific hardware backends before execution. Group commuting operations into the same Moment for maximum parallelism in circuit execution. Apply cirq.DensityMatrixSimulator for noise studies and cirq.Simulator for fast ideal state vector computations. When benchmarking algorithm performance, run both ideal and noisy simulations at matched shot counts to isolate the contribution of hardware noise to output distributions.

When to Use It?

Use Cases

Build a variational quantum eigensolver that estimates ground state energies for molecular systems. Create a quantum error correction simulator that tests surface code performance under realistic noise. Implement a quantum random number generator that certifies randomness through Bell inequality violations.

Related Topics

Quantum computing, quantum circuit simulation, quantum noise models, variational quantum algorithms, and quantum hardware backends.

Important Notes

Requirements

Python with the cirq-core package installed. NumPy for matrix and state vector operations. Optional cirq-google package for Google quantum hardware access with service credentials.

Usage Recommendations

Do: use Moments to explicitly control gate scheduling and parallelism in circuits. Validate circuits against device constraints before submitting to quantum hardware. Compare noisy simulation results with ideal simulations to quantify error impact.

Don't: build circuits with gates that violate the target device connectivity without routing. Run large qubit simulations on machines without sufficient RAM since state vectors grow exponentially. Assume noiseless results will match hardware outcomes without noise modeling.

Limitations

Classical simulation of quantum circuits is limited to roughly 30 qubits due to exponential memory requirements. Hardware access requires Google Cloud credentials and project authorization. Gate decompositions for arbitrary unitaries may introduce significant circuit depth overhead, which can amplify noise accumulation on near-term quantum devices.