tessl/pypi-cirq
A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
—
Pending
Quality
Pending
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
sim.mddocs/
Simulators and Simulation
The sim module provides classical simulation capabilities for quantum circuits, including multiple simulation backends optimized for different use cases and performance requirements. It supports state vector simulation, density matrix simulation, and specialized Clifford simulation.
Core Simulator Classes
Simulator - State Vector Simulator
The default sparse state vector simulator, efficient for pure state quantum circuits.
class Simulator(SimulatorBase):
"""Sparse state vector simulator."""
def __init__(self, *, dtype: Type[np.number] = np.complex64,
noise: 'cirq.NoiseModel' = None,
seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None) -> None:
"""Initialize state vector simulator.
Args:
dtype: Numeric type for state vector (complex64 or complex128)
noise: Noise model to apply during simulation
seed: Random seed for sampling and noise
"""
def run(self, program: 'cirq.CIRCUIT_LIKE',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
repetitions: int = 1) -> 'cirq.Result':
"""Run circuit and return measurement results.
Args:
program: Circuit to simulate
param_resolver: Parameters for the circuit
repetitions: Number of times to run the circuit
Returns:
Result containing measurement outcomes
"""
def run_sweep(self, program: 'cirq.CIRCUIT_LIKE',
params: 'cirq.Sweepable',
repetitions: int = 1) -> List['cirq.Result']:
"""Run circuit over parameter sweep."""
def simulate(self, program: 'cirq.CIRCUIT_LIKE',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT',
initial_state: 'cirq.STATE_VECTOR_LIKE' = None) -> 'StateVectorTrialResult':
"""Simulate circuit and return final state.
Args:
program: Circuit to simulate
param_resolver: Parameter values
qubit_order: Ordering of qubits in state vector
initial_state: Initial state vector
Returns:
Trial result with final state vector
"""
def simulate_sweep(self, program: 'cirq.CIRCUIT_LIKE',
params: 'cirq.Sweepable',
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT',
initial_state: 'cirq.STATE_VECTOR_LIKE' = None) -> List['StateVectorTrialResult']:
"""Simulate circuit over parameter sweep."""
def simulate_moment_steps(self, circuit: 'cirq.Circuit',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT',
initial_state: 'cirq.STATE_VECTOR_LIKE' = None) -> Iterator['StateVectorStepResult']:
"""Simulate circuit step by step, yielding after each moment."""DensityMatrixSimulator - Mixed State Simulator
Simulator using density matrix representation, supporting mixed states and decoherence.
class DensityMatrixSimulator(SimulatorBase):
"""Density matrix simulator for mixed state simulation."""
def __init__(self, *, dtype: Type[np.number] = np.complex64,
noise: 'cirq.NoiseModel' = None,
seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
ignore_measurement_results: bool = False) -> None:
"""Initialize density matrix simulator.
Args:
dtype: Numeric type for density matrix
noise: Noise model to apply
seed: Random seed
ignore_measurement_results: Whether to ignore measurement collapse
"""
def simulate(self, program: 'cirq.CIRCUIT_LIKE',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT',
initial_state: 'cirq.QUANTUM_STATE_LIKE' = None) -> 'DensityMatrixTrialResult':
"""Simulate circuit and return final density matrix.
Args:
program: Circuit to simulate
param_resolver: Parameter values
qubit_order: Qubit ordering
initial_state: Initial state (pure or mixed)
Returns:
Trial result with final density matrix
"""
def simulate_moment_steps(self, circuit: 'cirq.Circuit',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT',
initial_state: 'cirq.QUANTUM_STATE_LIKE' = None) -> Iterator['DensityMatrixStepResult']:
"""Simulate circuit step by step."""CliffordSimulator - Stabilizer State Simulator
Efficient simulator for Clifford circuits using stabilizer state representation.
class CliffordSimulator(SimulatorBase):
"""Clifford circuit simulator using stabilizer states."""
def __init__(self, *, seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None) -> None:
"""Initialize Clifford simulator."""
def run(self, program: 'cirq.CIRCUIT_LIKE',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
repetitions: int = 1) -> 'cirq.Result':
"""Run Clifford circuit."""
def simulate(self, program: 'cirq.CIRCUIT_LIKE',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT',
initial_state: Union['CliffordState', 'cirq.STATE_VECTOR_LIKE'] = None) -> 'CliffordTrialResult':
"""Simulate Clifford circuit and return stabilizer state.
Args:
program: Clifford circuit to simulate
param_resolver: Parameter values
qubit_order: Qubit ordering
initial_state: Initial stabilizer state
Returns:
Trial result with final Clifford state
"""
def simulate_moment_steps(self, circuit: 'cirq.Circuit',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT',
initial_state: Union['CliffordState', 'cirq.STATE_VECTOR_LIKE'] = None) -> Iterator['CliffordSimulatorStepResult']:
"""Simulate Clifford circuit step by step."""ClassicalStateSimulator - Classical Bit Simulator
Efficient simulator for classical circuits and reversible classical computation.
class ClassicalStateSimulator(SimulatorBase):
"""Classical state simulator for reversible classical computation."""
def __init__(self, *, seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None) -> None:
"""Initialize classical simulator."""
def simulate(self, program: 'cirq.CIRCUIT_LIKE',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT',
initial_state: Union[int, 'cirq.ProductState'] = 0) -> 'SimulationTrialResult':
"""Simulate classical circuit."""StabilizerSampler - Stabilizer State Sampling
Sampler for stabilizer states using efficient Clifford simulation.
class StabilizerSampler:
"""Sampler for stabilizer states."""
def __init__(self, *, seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None) -> None:
"""Initialize stabilizer sampler."""
def run(self, program: 'cirq.CIRCUIT_LIKE',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
repetitions: int = 1) -> 'cirq.Result':
"""Sample from stabilizer circuit."""Simulator Base Classes and Interfaces
SimulatorBase
Abstract base class for all simulators.
class SimulatorBase:
"""Abstract base class for simulators."""
def __init__(self, *, dtype: Optional[Type[np.number]] = None,
noise: 'cirq.NoiseModel' = None,
seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None) -> None:
"""Initialize simulator base."""
def run(self, program: 'cirq.CIRCUIT_LIKE',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
repetitions: int = 1) -> 'cirq.Result':
"""Run circuit and return measurement results."""
def run_sweep(self, program: 'cirq.CIRCUIT_LIKE',
params: 'cirq.Sweepable',
repetitions: int = 1) -> List['cirq.Result']:
"""Run circuit over parameter sweep."""
def sample(self, program: 'cirq.CIRCUIT_LIKE',
repetitions: int = 1,
params: 'cirq.Sweepable' = None) -> pd.DataFrame:
"""Sample measurement outcomes."""Simulation Interfaces
Interfaces that simulators can implement for different capabilities.
class SimulatesAmplitudes:
"""Interface for simulators that can compute amplitudes."""
def compute_amplitudes(self, program: 'cirq.CIRCUIT_LIKE',
bitstrings: Sequence[int],
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT') -> Sequence[complex]:
"""Compute amplitudes for given bitstrings."""
class SimulatesExpectationValues:
"""Interface for simulators that can compute expectation values."""
def simulate_expectation_values(self, program: 'cirq.CIRCUIT_LIKE',
observables: Union['cirq.PauliSumLike', List['cirq.PauliSumLike']],
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT',
initial_state: 'cirq.STATE_VECTOR_LIKE' = None,
permit_terminal_measurements: bool = False) -> List[float]:
"""Simulate expectation values of observables."""
class SimulatesFinalState:
"""Interface for simulators that can return final states."""
def simulate(self, program: 'cirq.CIRCUIT_LIKE',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT',
initial_state: Any = None) -> 'SimulationTrialResult':
"""Simulate circuit and return final state."""
class SimulatesIntermediateState:
"""Interface for simulators that can return intermediate states."""
def simulate_moment_steps(self, circuit: 'cirq.Circuit',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT',
initial_state: Any = None) -> Iterator['StepResult']:
"""Simulate circuit step by step."""
class SimulatesIntermediateStateVector:
"""Interface for simulators that can return intermediate state vectors."""
class SimulatesSamples:
"""Interface for simulators that can generate samples."""
def run(self, program: 'cirq.CIRCUIT_LIKE',
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
repetitions: int = 1) -> 'cirq.Result':
"""Run circuit and return samples."""Simulation States
SimulationState - Base State Class
class SimulationState:
"""Base class for simulation states."""
def __init__(self, qubits: Sequence['cirq.Qid'],
log_of_measurement_results: Dict[str, Any] = None) -> None:
"""Initialize simulation state.
Args:
qubits: Qubits being simulated
log_of_measurement_results: Measurement results log
"""
@property
def qubits(self) -> Tuple['cirq.Qid', ...]:
"""Qubits in the simulation."""
@property
def log_of_measurement_results(self) -> Dict[str, Any]:
"""Log of measurement results."""
def copy(self, deep_copy_buffers: bool = True) -> 'SimulationState':
"""Create a copy of the simulation state."""
class SimulationStateBase(SimulationState):
"""Enhanced base class for simulation states."""
def kronecker_product(self, other: 'SimulationStateBase') -> 'SimulationStateBase':
"""Compute tensor product with another state."""
def factor(self, qubits: Sequence['cirq.Qid'], *, validate: bool = True,
atol: float = 1e-07) -> Tuple['SimulationStateBase', 'SimulationStateBase']:
"""Factor state into two subsystems."""
def transpose_to_qubit_order(self, qubits: Sequence['cirq.Qid']) -> 'SimulationStateBase':
"""Transpose state to different qubit ordering."""StateVectorSimulationState - Pure State Vector
class StateVectorSimulationState(SimulationStateBase):
"""Simulation state using state vector representation."""
def __init__(self, qubits: Sequence['cirq.Qid'],
initial_state: 'cirq.STATE_VECTOR_LIKE' = 0,
dtype: Type[np.number] = np.complex64,
log_of_measurement_results: Dict[str, Any] = None) -> None:
"""Initialize state vector simulation state."""
@property
def target_tensor(self) -> np.ndarray:
"""State vector tensor."""
@property
def available_buffer(self) -> np.ndarray:
"""Available buffer for computations."""
def bloch_vector_of(self, qubit: 'cirq.Qid') -> np.ndarray:
"""Get Bloch vector representation of a qubit."""
def density_matrix_of(self, qubits: Sequence['cirq.Qid'] = None) -> np.ndarray:
"""Get density matrix of specified qubits."""
def dirac_notation(self, decimals: int = 2) -> str:
"""Get Dirac notation representation."""DensityMatrixSimulationState - Mixed State
class DensityMatrixSimulationState(SimulationStateBase):
"""Simulation state using density matrix representation."""
def __init__(self, qubits: Sequence['cirq.Qid'],
initial_state: 'cirq.QUANTUM_STATE_LIKE' = 0,
dtype: Type[np.number] = np.complex64,
log_of_measurement_results: Dict[str, Any] = None) -> None:
"""Initialize density matrix simulation state."""
@property
def target_tensor(self) -> np.ndarray:
"""Density matrix tensor."""
def density_matrix_of(self, qubits: Sequence['cirq.Qid'] = None) -> np.ndarray:
"""Get density matrix of specified qubits."""
def bloch_vector_of(self, qubit: 'cirq.Qid') -> np.ndarray:
"""Get Bloch vector of a single qubit."""Clifford and Stabilizer States
class CliffordTableauSimulationState(SimulationStateBase):
"""Simulation state using Clifford tableau representation."""
def __init__(self, tableau: 'cirq.CliffordTableau',
qubits: Sequence['cirq.Qid'],
log_of_measurement_results: Dict[str, Any] = None) -> None:
"""Initialize Clifford tableau state."""
class StabilizerSimulationState(SimulationStateBase):
"""General stabilizer simulation state."""
class StabilizerChFormSimulationState(SimulationStateBase):
"""Stabilizer state in CH-form representation."""
class StabilizerStateChForm:
"""CH-form stabilizer state representation."""
def __init__(self, num_qubits: int, initial_state: int = 0) -> None:
"""Initialize CH-form stabilizer state."""
def copy(self) -> 'StabilizerStateChForm':
"""Create a copy of the state."""
def inner_product_of_state_and_x(self, x: int) -> complex:
"""Compute <ψ|x> where |x> is computational basis state."""
def to_numpy(self) -> np.ndarray:
"""Convert to numpy state vector (exponential cost)."""Product States
class SimulationProductState(SimulationStateBase):
"""Product state simulation (for classical-like states)."""
def __init__(self, qubits: Sequence['cirq.Qid'],
initial_state: Union[int, Dict['cirq.Qid', int], 'cirq.ProductState'] = 0,
log_of_measurement_results: Dict[str, Any] = None) -> None:
"""Initialize product state."""
@property
def state(self) -> Dict['cirq.Qid', int]:
"""Current computational basis state."""State Vector Mixin
class StateVectorMixin:
"""Mixin providing state vector functionality."""
def state_vector(self) -> np.ndarray:
"""Get the full state vector."""
def dirac_notation(self, decimals: int = 2) -> str:
"""Get Dirac notation string."""
def bloch_vector_of(self, qubit: 'cirq.Qid') -> np.ndarray:
"""Get Bloch vector of single qubit."""Simulation Results
Trial Results - Final State Results
class SimulationTrialResult:
"""Result of a single simulation trial."""
def __init__(self, params: 'cirq.ParamResolver',
measurements: Dict[str, np.ndarray],
final_simulator_state: 'SimulationState') -> None:
"""Initialize trial result."""
@property
def params(self) -> 'cirq.ParamResolver':
"""Parameters used in this trial."""
@property
def measurements(self) -> Dict[str, np.ndarray]:
"""Measurement results keyed by measurement key."""
@property
def final_simulator_state(self) -> 'SimulationState':
"""Final simulation state after circuit execution."""
def histogram(self, *, key: str, fold_func: Callable = None) -> Dict[Any, int]:
"""Get histogram of measurement results."""
class SimulationTrialResultBase(SimulationTrialResult):
"""Base class for trial results with additional methods."""
def qubit_map(self) -> Dict['cirq.Qid', int]:
"""Map from qubits to their index in the state."""
def density_matrix_of(self, qubits: Sequence['cirq.Qid'] = None) -> np.ndarray:
"""Get density matrix of specified qubits."""Specific Trial Result Types
class StateVectorTrialResult(SimulationTrialResultBase, StateVectorMixin):
"""Trial result for state vector simulation."""
@property
def final_state_vector(self) -> np.ndarray:
"""Final state vector."""
class DensityMatrixTrialResult(SimulationTrialResultBase):
"""Trial result for density matrix simulation."""
@property
def final_density_matrix(self) -> np.ndarray:
"""Final density matrix."""
class CliffordTrialResult(SimulationTrialResultBase):
"""Trial result for Clifford simulation."""
@property
def final_state(self) -> 'CliffordState':
"""Final Clifford state."""
class CliffordState:
"""Clifford stabilizer state."""
def __init__(self, tableau: 'cirq.CliffordTableau',
qubits: Sequence['cirq.Qid'] = None) -> None:
"""Initialize Clifford state."""
def stabilizers(self) -> List['cirq.PauliString']:
"""Get stabilizer generators."""
def destabilizers(self) -> List['cirq.PauliString']:
"""Get destabilizer generators."""
def to_numpy(self) -> np.ndarray:
"""Convert to state vector (exponential cost)."""Step Results - Intermediate States
class StepResult:
"""Result after simulating one moment."""
def __init__(self, simulator_state: 'SimulationState') -> None:
"""Initialize step result."""
@property
def simulator_state(self) -> 'SimulationState':
"""Simulation state after this step."""
class StepResultBase(StepResult):
"""Enhanced step result with additional methods."""
def density_matrix_of(self, qubits: Sequence['cirq.Qid'] = None) -> np.ndarray:
"""Get density matrix of qubits."""
def qubit_map(self) -> Dict['cirq.Qid', int]:
"""Get qubit index mapping."""
class StateVectorStepResult(StepResultBase, StateVectorMixin):
"""Step result for state vector simulation."""
@property
def state_vector(self) -> np.ndarray:
"""Current state vector."""
class DensityMatrixStepResult(StepResultBase):
"""Step result for density matrix simulation."""
@property
def density_matrix(self) -> np.ndarray:
"""Current density matrix."""
class CliffordSimulatorStepResult(StepResultBase):
"""Step result for Clifford simulation."""
class SparseSimulatorStep(StateVectorStepResult):
"""Step result for sparse state vector simulator."""High-Level Simulation Functions
Convenient functions for common simulation tasks.
def sample(program: 'cirq.CIRCUIT_LIKE', *, repetitions: int = 1,
noise: 'cirq.NoiseModel' = None,
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None) -> 'cirq.Result':
"""Sample measurement outcomes from a circuit.
Args:
program: Circuit to sample from
repetitions: Number of samples to collect
noise: Noise model to apply
param_resolver: Parameter values
seed: Random seed
Returns:
Result containing measurement samples
"""
def sample_sweep(program: 'cirq.CIRCUIT_LIKE', params: 'cirq.Sweepable', *,
repetitions: int = 1,
noise: 'cirq.NoiseModel' = None,
seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None) -> List['cirq.Result']:
"""Sample over parameter sweep."""
def final_state_vector(program: 'cirq.CIRCUIT_LIKE', *,
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT',
initial_state: 'cirq.STATE_VECTOR_LIKE' = None,
seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None) -> np.ndarray:
"""Get final state vector after circuit execution.
Args:
program: Circuit to simulate
param_resolver: Parameter values
qubit_order: Qubit ordering for state vector
initial_state: Initial state vector
seed: Random seed
Returns:
Final state vector as numpy array
"""
def final_density_matrix(program: 'cirq.CIRCUIT_LIKE', *,
param_resolver: 'cirq.ParamResolverOrSimilarType' = None,
qubit_order: 'cirq.QubitOrderOrList' = 'cirq.QubitOrder.DEFAULT',
initial_state: 'cirq.QUANTUM_STATE_LIKE' = None,
seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None) -> np.ndarray:
"""Get final density matrix after circuit execution."""Direct State Measurement Functions
def measure_state_vector(state_vector: np.ndarray, indices: List[int], *,
qid_shape: Tuple[int, ...] = None,
out: np.ndarray = None,
seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None) -> Tuple[List[int], np.ndarray]:
"""Measure state vector and return outcomes and post-measurement state.
Args:
state_vector: State vector to measure
indices: Indices of qubits to measure
qid_shape: Shape of qid system
out: Output buffer for result state
seed: Random seed
Returns:
Tuple of (measurement_outcomes, post_measurement_state)
"""
def sample_state_vector(state_vector: np.ndarray, indices: List[int], *,
qid_shape: Tuple[int, ...] = None,
repetitions: int = 1,
seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None) -> np.ndarray:
"""Sample measurements from state vector without collapse."""
def measure_density_matrix(density_matrix: np.ndarray, indices: List[int], *,
qid_shape: Tuple[int, ...] = None,
out: np.ndarray = None,
seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None) -> Tuple[List[int], np.ndarray]:
"""Measure density matrix and return outcomes and post-measurement state."""
def sample_density_matrix(density_matrix: np.ndarray, indices: List[int], *,
qid_shape: Tuple[int, ...] = None,
repetitions: int = 1,
seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None) -> np.ndarray:
"""Sample measurements from density matrix without collapse."""Type Aliases
CIRCUIT_LIKE = Union['cirq.AbstractCircuit', 'cirq.FrozenCircuit', Iterable[Any]]
"""Type alias for circuit-like objects."""Usage Examples
Basic Circuit Simulation
import cirq
import numpy as np
# Create a simple quantum circuit
qubits = cirq.LineQubit.range(2)
circuit = cirq.Circuit([
cirq.H(qubits[0]),
cirq.CNOT(qubits[0], qubits[1]),
cirq.measure(*qubits, key='result')
])
# Simulate with different backends
print("=== State Vector Simulation ===")
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=100)
print(f"Measurement histogram: {result.histogram(key='result')}")
# Get final state without measurement
circuit_no_measure = circuit[:-1]
final_state = simulator.simulate(circuit_no_measure)
print(f"Final state vector shape: {final_state.final_state_vector.shape}")
print(f"Final state (Dirac notation): {final_state.dirac_notation()}")
print("\n=== Density Matrix Simulation ===")
dm_simulator = cirq.DensityMatrixSimulator()
dm_result = dm_simulator.simulate(circuit_no_measure)
print(f"Final density matrix shape: {dm_result.final_density_matrix.shape}")Noisy Simulation
import cirq
# Create circuit with noise
qubits = cirq.LineQubit.range(2)
circuit = cirq.Circuit([
cirq.H(qubits[0]),
cirq.CNOT(qubits[0], qubits[1])
])
# Define noise model
noise_model = cirq.ConstantQubitNoiseModel(cirq.depolarize(p=0.01))
# Simulate with noise using density matrix
dm_simulator = cirq.DensityMatrixSimulator(noise=noise_model)
noisy_result = dm_simulator.simulate(circuit)
print("Clean vs Noisy Simulation:")
clean_result = cirq.DensityMatrixSimulator().simulate(circuit)
print(f"Clean final state purity: {np.trace(clean_result.final_density_matrix @ clean_result.final_density_matrix).real:.4f}")
print(f"Noisy final state purity: {np.trace(noisy_result.final_density_matrix @ noisy_result.final_density_matrix).real:.4f}")Step-by-Step Simulation
import cirq
# Create multi-moment circuit
qubits = cirq.LineQubit.range(2)
circuit = cirq.Circuit([
cirq.H(qubits[0]),
cirq.Moment([cirq.X(qubits[1])]),
cirq.CNOT(qubits[0], qubits[1]),
cirq.Moment([cirq.Z(qubits[0]), cirq.Y(qubits[1])])
])
# Simulate step by step
simulator = cirq.Simulator()
print("Step-by-step simulation:")
for i, step_result in enumerate(simulator.simulate_moment_steps(circuit)):
print(f"After moment {i}: {step_result.dirac_notation()}")Clifford Circuit Simulation
import cirq
# Create Clifford circuit (only Clifford gates)
qubits = cirq.LineQubit.range(3)
clifford_circuit = cirq.Circuit([
cirq.H(qubits[0]),
cirq.CNOT(qubits[0], qubits[1]),
cirq.S(qubits[2]),
cirq.CZ(qubits[1], qubits[2]),
cirq.measure(*qubits, key='result')
])
# Use Clifford simulator for efficiency
clifford_sim = cirq.CliffordSimulator()
result = clifford_sim.run(clifford_circuit, repetitions=1000)
print(f"Clifford simulation results: {result.histogram(key='result')}")
# Get stabilizer representation
final_state = clifford_sim.simulate(clifford_circuit[:-1]) # Without measurement
print(f"Final Clifford state stabilizers: {final_state.final_state.stabilizers()[:3]}")High-Level Convenience Functions
import cirq
import numpy as np
# Using convenience functions
qubits = cirq.LineQubit.range(2)
circuit = cirq.Circuit([
cirq.H(qubits[0]),
cirq.CNOT(qubits[0], qubits[1])
])
# Get final state vector directly
final_state = cirq.final_state_vector(circuit)
print(f"Final state: {final_state}")
# Sample directly from circuit
samples = cirq.sample(circuit + cirq.measure(*qubits, key='result'), repetitions=100)
print(f"Direct sampling: {samples.histogram(key='result')}")
# Parameterized simulation
import sympy
theta = sympy.Symbol('theta')
param_circuit = cirq.Circuit([
cirq.rx(theta)(qubits[0]),
cirq.CNOT(qubits[0], qubits[1])
])
# Sweep over parameter values
param_sweep = cirq.Linspace('theta', 0, np.pi, 5)
results = cirq.sample_sweep(param_circuit + cirq.measure(*qubits, key='result'),
param_sweep, repetitions=100)
for i, result in enumerate(results):
theta_val = param_sweep[i].param_dict['theta']
print(f"θ = {theta_val:.3f}: {result.histogram(key='result')}")This comprehensive simulation framework provides the foundation for classical quantum circuit simulation with multiple backends optimized for different use cases and performance requirements.
Install with Tessl CLI
npx tessl i tessl/pypi-cirq