def test_constant_qubit_noise():
a, b, c = cirq.LineQubit.range(3)
damp = cirq.amplitude_damp(0.5)
damp_all = cirq.ConstantQubitNoiseModel(damp)
actual = damp_all.noisy_moments(
[cirq.Moment([cirq.X(a)]), cirq.Moment()], [a, b, c])
expected = [
[
cirq.Moment([cirq.X(a)]),
cirq.Moment(
d.with_tags(ops.VirtualTag())
for d in [damp(a), damp(b), damp(c)]),
],
[
cirq.Moment(),
cirq.Moment(
d.with_tags(ops.VirtualTag())
for d in [damp(a), damp(b), damp(c)]),
],
]
assert actual == expected
cirq.testing.assert_equivalent_repr(damp_all)
with pytest.raises(ValueError, match='num_qubits'):
_ = cirq.ConstantQubitNoiseModel(cirq.CNOT**0.01)
def test_noise_composition():
# Verify that noise models can be composed without regard to ordering, as
# long as the noise operators commute with one another.
a, b, c = cirq.LineQubit.range(3)
noise_z = cirq.ConstantQubitNoiseModel(cirq.Z)
noise_inv_s = cirq.ConstantQubitNoiseModel(cirq.S**-1)
base_moments = [
cirq.Moment([cirq.X(a)]),
cirq.Moment([cirq.Y(b)]),
cirq.Moment([cirq.H(c)])
]
circuit_z = cirq.Circuit(noise_z.noisy_moments(base_moments, [a, b, c]))
circuit_s = cirq.Circuit(noise_inv_s.noisy_moments(base_moments,
[a, b, c]))
actual_zs = cirq.Circuit(
noise_inv_s.noisy_moments(circuit_z.moments, [a, b, c]))
actual_sz = cirq.Circuit(
noise_z.noisy_moments(circuit_s.moments, [a, b, c]))
expected_circuit = cirq.Circuit(
cirq.Moment([cirq.X(a)]),
cirq.Moment([cirq.S(a), cirq.S(b), cirq.S(c)]),
cirq.Moment([cirq.Y(b)]),
cirq.Moment([cirq.S(a), cirq.S(b), cirq.S(c)]),
cirq.Moment([cirq.H(c)]),
cirq.Moment([cirq.S(a), cirq.S(b), cirq.S(c)]),
)
# All of the gates will be the same, just out of order. Merging fixes this.
actual_zs = cirq.merge_single_qubit_gates_to_phased_x_and_z(actual_zs)
actual_sz = cirq.merge_single_qubit_gates_to_phased_x_and_z(actual_sz)
expected_circuit = cirq.merge_single_qubit_gates_to_phased_x_and_z(
expected_circuit)
assert_equivalent_op_tree(actual_zs, actual_sz)
assert_equivalent_op_tree(actual_zs, expected_circuit)
def test_constant_qubit_noise():
a, b, c = cirq.LineQubit.range(3)
damp = cirq.amplitude_damp(0.5)
damp_all = cirq.ConstantQubitNoiseModel(damp)
assert damp_all.noisy_moments(
[cirq.Moment([cirq.X(a)]), cirq.Moment()],
[a, b, c]) == [[cirq.X(a), damp(a),
damp(b), damp(c)], [damp(a), damp(b),
damp(c)]]
with pytest.raises(ValueError, match='num_qubits'):
_ = cirq.ConstantQubitNoiseModel(cirq.CNOT**0.01)
def noisy_circuit_demo(amplitude_damp):
"""Demonstrates a noisy circuit simulation.
"""
# q = cirq.NamedQubit('q')
q = cirq.LineQubit(0)
dm_circuit = cirq.Circuit(cirq.X(q), )
dm_result = cirq.DensityMatrixSimulator(noise=cirq.ConstantQubitNoiseModel(
cirq.amplitude_damp(amplitude_damp))).simulate(program=dm_circuit)
kc_circuit = cirq.Circuit(cirq.amplitude_damp(amplitude_damp)(q), )
kc_result = cirq.KnowledgeCompilationSimulator(
kc_circuit, initial_state=1, intermediate=False).simulate(kc_circuit)
print("dm_result.final_density_matrix")
print(dm_result.final_density_matrix)
print("kc_result.final_density_matrix")
print(kc_result.final_density_matrix)
np.testing.assert_almost_equal(dm_result.final_density_matrix,
kc_result.final_density_matrix)
dm_circuit.append(cirq.measure(q, key='after_not_gate'))
kc_circuit.append(cirq.measure(q, key='after_not_gate'))
dm_results = cirq.sample(program=dm_circuit,
noise=cirq.ConstantQubitNoiseModel(
cirq.amplitude_damp(amplitude_damp)),
repetitions=10000)
kc_simulator = cirq.KnowledgeCompilationSimulator(kc_circuit,
initial_state=1,
intermediate=False)
kc_results = kc_simulator.run(kc_circuit, repetitions=10000)
print(
"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
)
print("ConstantQubitNoiseModel with amplitude damping of rate",
cirq.amplitude_damp(amplitude_damp))
print(
'DENSITY_MATRIX_SIMULATOR: Sampling of qubit "q" after application of X gate:'
)
print(dm_results.histogram(key='after_not_gate'))
print(
'KNOWLEDGE_COMPILATION_SIMULATOR: Sampling of qubit "q" after application of X gate:'
)
print(kc_results.histogram(key='after_not_gate'))
print(
"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
)
def introduce_noise_type(
op_tree: cirq.OP_TREE,
noise_func: Callable[[], List[cirq.Gate]]) -> cirq.OP_TREE:
result = []
for op_list in op_tree:
for gate_op in op_list:
noise_list = noise_func(
) # Create random noise operation per gate operation
new_gate_list = [gate_op]
for noise_op in noise_list:
noise_model = cirq.ConstantQubitNoiseModel(noise_op)
# Check if evaluated gate is no virtual noise moment
if isinstance(
new_gate_list[0],
cirq.Moment) and noise_model.is_virtual_moment(
new_gate_list[0]):
continue
# Handle obscure noisy_operation function output
new_moment_list = noise_model.noisy_operation(
operation=new_gate_list[0])
new_gate_list.append(
new_moment_list[1]
) # Collects the added noise moment after gate operation
# Append to new moment
result.append(new_gate_list)
result = [val for sublist in result
for val in sublist] # Flatten list of list of cirq.Moments
return result
def test_sample_sweep():
q = cirq.NamedQubit('q')
c = cirq.Circuit.from_ops(cirq.X(q),
cirq.Y(q)**sympy.Symbol('t'), cirq.measure(q))
# Unitary.
results = cirq.sample_sweep(c, cirq.Linspace('t', 0, 1, 2), repetitions=3)
assert len(results) == 2
assert results[0].histogram(key=q) == collections.Counter({1: 3})
assert results[1].histogram(key=q) == collections.Counter({0: 3})
# Overdamped.
c = cirq.Circuit.from_ops(cirq.X(q),
cirq.amplitude_damp(1).on(q),
cirq.Y(q)**sympy.Symbol('t'), cirq.measure(q))
results = cirq.sample_sweep(c, cirq.Linspace('t', 0, 1, 2), repetitions=3)
assert len(results) == 2
assert results[0].histogram(key=q) == collections.Counter({0: 3})
assert results[1].histogram(key=q) == collections.Counter({1: 3})
# Overdamped everywhere.
c = cirq.Circuit.from_ops(cirq.X(q),
cirq.Y(q)**sympy.Symbol('t'), cirq.measure(q))
results = cirq.sample_sweep(c,
cirq.Linspace('t', 0, 1, 2),
noise=cirq.ConstantQubitNoiseModel(
cirq.amplitude_damp(1)),
repetitions=3)
assert len(results) == 2
assert results[0].histogram(key=q) == collections.Counter({0: 3})
assert results[1].histogram(key=q) == collections.Counter({0: 3})
def test_svg_noise():
noise_model = cirq.ConstantQubitNoiseModel(cirq.DepolarizingChannel(p=1e-3))
q = cirq.LineQubit(0)
circuit = cirq.Circuit(cirq.X(q))
circuit = cirq.Circuit(noise_model.noisy_moments(circuit.moments, [q]))
svg = circuit_to_svg(circuit)
assert '>D(0.001)</text>' in svg
def objective_function_monte_carlo(self, u_params):
U = U4(u_params)
V = self.get_env(U)
assert abs(
full_tomography_env_objective_function(FullStateTensor(U),
FullEnvironment(V))) < 1e-6
qbs = cirq.LineQubit.range(4)
C = cirq.Circuit().from_ops(
cirq.decompose(
State(FullStateTensor(U), FullEnvironment(V), 2)(*qbs)))
noise = cirq.ConstantQubitNoiseModel(
cirq.depolarize(self.depolarizing_prob))
system_qubits = sorted(C.all_qubits())
noisy_circuit = cirq.Circuit()
for moment in C:
noisy_circuit.append(noise.noisy_moment(moment, system_qubits))
sim = cirq.Simulator()
ψ = sim.simulate(noisy_circuit).final_state
H = kron(kron(eye(2), self.H), eye(2))
f = real(ψ.conj().T @ H @ ψ)
#sim = cirq.DensityMatrixSimulator(noise=noise)
#ρ = sim.simulate(noisy_circuit).final_density_matrix
#f = real(trace(ρ@H))
return f
def test_sample():
q = cirq.NamedQubit('q')
with pytest.raises(ValueError, match="no measurements"):
cirq.sample(cirq.Circuit.from_ops(cirq.X(q)))
# Unitary.
results = cirq.sample(cirq.Circuit.from_ops(cirq.X(q), cirq.measure(q)))
assert results.histogram(key=q) == collections.Counter({1: 1})
# Intermediate measurements.
results = cirq.sample(
cirq.Circuit.from_ops(
cirq.measure(q, key='drop'),
cirq.X(q),
cirq.measure(q),
))
assert results.histogram(key='drop') == collections.Counter({0: 1})
assert results.histogram(key=q) == collections.Counter({1: 1})
# Overdamped everywhere.
results = cirq.sample(cirq.Circuit.from_ops(
cirq.measure(q, key='drop'),
cirq.X(q),
cirq.measure(q),
),
noise=cirq.ConstantQubitNoiseModel(
cirq.amplitude_damp(1)))
assert results.histogram(key='drop') == collections.Counter({0: 1})
assert results.histogram(key=q) == collections.Counter({0: 1})
def main(*, num_qubits: int, depth: int, num_circuits: int, seed: int,
routes: int):
"""Run the quantum volume algorithm with a preset configuration.
See the calculate_quantum_volume documentation for more details.
Args:
num_qubits: Pass-through to calculate_quantum_volume.
depth: Pass-through to calculate_quantum_volume
num_circuits: Pass-through to calculate_quantum_volume
seed: Pass-through to calculate_quantum_volume
Returns: Pass-through from calculate_quantum_volume.
"""
device = cirq.google.Bristlecone
compiler = lambda circuit: cirq.google.optimized_for_xmon(
circuit=circuit, new_device=device)
noisy = cirq.DensityMatrixSimulator(noise=cirq.ConstantQubitNoiseModel(
qubit_noise_gate=cirq.DepolarizingChannel(p=0.005)))
calculate_quantum_volume(num_qubits=num_qubits,
depth=depth,
num_circuits=num_circuits,
random_state=seed,
device_or_qubits=device,
samplers=[cirq.Simulator(), noisy],
routing_attempts=routes,
compiler=compiler)
def objective_function_monte_carlo(self, u_params):
U = self.state_tensor(self.D, u_params)
V = FullEnvironment(get_env_exact(cirq.unitary(U))) # for testing
qbs = cirq.LineQubit.range(int(2 * np.log2(self.D) + 2))
C = cirq.Circuit().from_ops(cirq.decompose(State(U, V, 2)(*qbs)))
noise = cirq.ConstantQubitNoiseModel(
cirq.depolarize(self.depolarizing_prob))
system_qubits = sorted(C.all_qubits())
noisy_circuit = cirq.Circuit()
for moment in C:
noisy_circuit.append(noise.noisy_moment(moment, system_qubits))
sim = cirq.Simulator()
ψ = sim.simulate(noisy_circuit).final_state
H = kron(kron(eye(self.D), self.H), eye(self.D))
f = real(ψ.conj().T @ H @ ψ)
#sim = cirq.DensityMatrixSimulator(noise=noise)
#ρ = sim.simulate(noisy_circuit).final_density_matrix
#f = real(trace(ρ@H))
return f
def test_tensor_density_matrix_4():
qubits = cirq.LineQubit.range(4)
circuit = cirq.testing.random_circuit(qubits=qubits, n_moments=100, op_density=0.8)
cirq.DropEmptyMoments().optimize_circuit(circuit)
noise_model = cirq.ConstantQubitNoiseModel(cirq.DepolarizingChannel(p=1e-3))
circuit = cirq.Circuit(noise_model.noisy_moments(circuit.moments, qubits))
rho1 = cirq.final_density_matrix(circuit, dtype=np.complex128)
rho2 = ccq.tensor_density_matrix(circuit, qubits)
np.testing.assert_allclose(rho1, rho2, atol=1e-8)
def test_tensor_density_matrix_gridqubit():
qubits = cirq.GridQubit.rect(2, 2)
circuit = cirq.testing.random_circuit(qubits=qubits, n_moments=10, op_density=0.8)
circuit = cirq.drop_empty_moments(circuit)
noise_model = cirq.ConstantQubitNoiseModel(cirq.DepolarizingChannel(p=1e-3))
circuit = cirq.Circuit(noise_model.noisy_moments(circuit.moments, qubits))
rho1 = cirq.final_density_matrix(circuit, dtype=np.complex128)
rho2 = ccq.tensor_density_matrix(circuit, qubits)
np.testing.assert_allclose(rho1, rho2, atol=1e-8)
def syc23_noisy(state):
return qb.CirqBoard(
state,
sampler=cirq.DensityMatrixSimulator(noise=cirq.ConstantQubitNoiseModel(
qubit_noise_gate=cirq.DepolarizingChannel(0.005)),
seed=get_seed()),
device=utils.get_device_obj_by_name('Syc23-simulator'),
error_mitigation=enums.ErrorMitigation.Correct,
noise_mitigation=0.10)
def test_nondeterministic_mixture_noise():
q = cirq.LineQubit(0)
circuit = cirq.Circuit(cirq.I(q), cirq.measure(q))
simulator = cirq.Simulator(noise=cirq.ConstantQubitNoiseModel(cirq.depolarize(0.5)))
result1 = simulator.run(circuit, repetitions=50)
result2 = simulator.run(circuit, repetitions=50)
assert result1 != result2
def main():
circuit, qubits = build_circuit()
circuit.append(cirq.measure(*qubits, key='y'))
noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1))
estimated_fidelity = direct_fidelity_estimation(circuit,
qubits,
noise,
n_trials=10)
print(estimated_fidelity)
def test_wrap():
class Forget(cirq.NoiseModel):
def noisy_operation(self, operation):
raise NotImplementedError()
forget = Forget()
assert cirq.NoiseModel.from_noise_model_like(None) is cirq.NO_NOISE
assert cirq.NoiseModel.from_noise_model_like(
cirq.depolarize(0.1)) == cirq.ConstantQubitNoiseModel(
cirq.depolarize(0.1))
assert cirq.NoiseModel.from_noise_model_like(
cirq.Z**0.01) == cirq.ConstantQubitNoiseModel(cirq.Z**0.01)
assert cirq.NoiseModel.from_noise_model_like(forget) is forget
with pytest.raises(TypeError, match='Expected a NOISE_MODEL_LIKE'):
_ = cirq.NoiseModel.from_noise_model_like('test')
with pytest.raises(ValueError, match='Multi-qubit gate'):
_ = cirq.NoiseModel.from_noise_model_like(cirq.CZ**0.01)
def test_direct_fidelity_estimation():
qubits = cirq.LineQubit.range(3)
circuit = cirq.Circuit(
cirq.Z(qubits[0])**0.25, # T-Gate, non Clifford.
cirq.X(qubits[1])**0.123,
cirq.X(qubits[2])**0.456)
noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1))
estimated_fidelity = direct_fidelity_estimation.direct_fidelity_estimation(
circuit, qubits, noise, n_trials=10)
assert estimated_fidelity >= -1.0 and estimated_fidelity <= 1.0
def test_final_density_matrix_noise():
a = cirq.LineQubit(0)
np.testing.assert_allclose(cirq.final_density_matrix(
[cirq.H(a), cirq.Z(a),
cirq.H(a), cirq.measure(a)]), [[0, 0], [0, 1]],
atol=1e-4)
np.testing.assert_allclose(cirq.final_density_matrix(
[cirq.H(a), cirq.Z(a),
cirq.H(a), cirq.measure(a)],
noise=cirq.ConstantQubitNoiseModel(cirq.amplitude_damp(1.0))),
[[1, 0], [0, 0]],
atol=1e-4)
def main(*, n_measured_operators: Optional[int], samples_per_term: int):
circuit, qubits = build_circuit()
noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1))
print('Noise model: %s' % (noise))
noisy_simulator = cirq.DensityMatrixSimulator(noise=noise)
estimated_fidelity, _ = direct_fidelity_estimation(
circuit,
qubits,
noisy_simulator,
n_measured_operators=n_measured_operators,
samples_per_term=samples_per_term)
print('Estimated fidelity: %f' % (estimated_fidelity))
def main(*, n_trials: int, samples_per_term: int):
circuit, qubits = build_circuit()
circuit.append(cirq.measure(*qubits, key='y'))
noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1))
print('Noise model: %s' % (noise))
estimated_fidelity = direct_fidelity_estimation(
circuit,
qubits,
noise,
n_trials=n_trials,
samples_per_term=samples_per_term)
print('Estimated fidelity: %f' % (estimated_fidelity))
def test_direct_fidelity_estimation_with_noise_clifford():
qubits = cirq.LineQubit.range(3)
circuit = cirq.Circuit(cirq.Z(qubits[0]), cirq.X(qubits[1]),
cirq.X(qubits[2]))
noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1))
noisy_simulator = cirq.DensityMatrixSimulator(noise=noise)
estimated_fidelity, _ = dfe.direct_fidelity_estimation(
circuit,
qubits,
noisy_simulator,
n_measured_operators=None,
samples_per_term=100)
assert estimated_fidelity >= -1.0 and estimated_fidelity <= 1.0
def main(*, n_trials: int, n_clifford_trials: int, samples_per_term: int):
circuit, qubits = build_circuit()
noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1))
print('Noise model: %s' % (noise))
noisy_simulator = cirq.DensityMatrixSimulator(noise=noise)
estimated_fidelity = direct_fidelity_estimation(
circuit,
qubits,
noisy_simulator,
n_trials=n_trials,
n_clifford_trials=n_clifford_trials,
samples_per_term=samples_per_term)
print('Estimated fidelity: %f' % (estimated_fidelity))
def get_sampler(self, ) -> 'cirq.Sampler':
"""Return a local `cirq.Sampler` based on the `noise_strength` attribute.
If `self.noise_strength` is `0` return a noiseless state-vector simulator.
If it's set to `float('inf')` the simulator will be `cirq.ZerosSampler`.
Otherwise, we return a density matrix simulator with a depolarizing model with
`noise_strength` probability of noise.
"""
if self.noise_strength == 0:
return cirq.Simulator()
if self.noise_strength == float('inf'):
return cirq.ZerosSampler()
return cirq.DensityMatrixSimulator(noise=cirq.ConstantQubitNoiseModel(
cirq.depolarize(p=self.noise_strength)))
def test_direct_fidelity_estimation_no_noise_non_clifford():
qubits = cirq.LineQubit.range(3)
circuit = cirq.Circuit(
cirq.Z(qubits[0])**0.123, cirq.X(qubits[1]), cirq.X(qubits[2]))
no_noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.0))
estimated_fidelity = direct_fidelity_estimation.direct_fidelity_estimation(
circuit,
qubits,
no_noise,
n_trials=100,
n_clifford_trials=3,
samples_per_term=0)
assert np.isclose(estimated_fidelity, 1.0, atol=0.01)
def test_direct_fidelity_estimation_no_noise_clifford():
qubits = cirq.LineQubit.range(3)
circuit = cirq.Circuit(cirq.Z(qubits[0]), cirq.X(qubits[1]),
cirq.X(qubits[2]))
no_noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.0))
no_noise_simulator = cirq.DensityMatrixSimulator(noise=no_noise)
estimated_fidelity, _ = dfe.direct_fidelity_estimation(circuit,
qubits,
no_noise_simulator,
n_trials=100,
n_clifford_trials=3,
samples_per_term=0)
assert np.isclose(estimated_fidelity, 1.0, atol=0.01)
def test_direct_fidelity_estimation_with_noise_non_clifford():
qubits = cirq.LineQubit.range(3)
circuit = cirq.Circuit(
cirq.Z(qubits[0])**0.25, # T-Gate, non Clifford.
cirq.X(qubits[1])**0.123,
cirq.X(qubits[2])**0.456)
noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1))
noisy_simulator = cirq.KnowledgeCompilationSimulator(circuit, noise=noise)
estimated_fidelity, _ = dfe.direct_fidelity_estimation(
circuit,
qubits,
noisy_simulator,
n_measured_operators=None,
samples_per_term=100)
assert estimated_fidelity >= -1.0 and estimated_fidelity <= 1.0
def test_direct_fidelity_estimation_with_noise():
qubits = cirq.LineQubit.range(3)
circuit = cirq.Circuit(
cirq.Z(qubits[0])**0.25, # T-Gate, non Clifford.
cirq.X(qubits[1])**0.123,
cirq.X(qubits[2])**0.456)
noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.1))
noisy_simulator = cirq.DensityMatrixSimulator(noise=noise)
estimated_fidelity, _ = dfe.direct_fidelity_estimation(circuit,
qubits,
noisy_simulator,
n_trials=10,
n_clifford_trials=3,
samples_per_term=10)
assert estimated_fidelity >= -1.0 and estimated_fidelity <= 1.0
def noisy_circuit_demo(amplitude_damp):
"""Demonstrates a noisy circuit simulation.
"""
q = cirq.NamedQubit('q')
circuit = cirq.Circuit.from_ops(
cirq.measure(q, key='initial_state'),
cirq.X(q),
cirq.measure(q, key='after_not_gate'),
)
results = cirq.sample(program=circuit,
noise=cirq.ConstantQubitNoiseModel(
cirq.amplitude_damp(amplitude_damp)),
repetitions=100)
print("ConstantQubitNoiseModel with amplitude damping of rate",
cirq.amplitude_damp(amplitude_damp))
print('Sampling of initial state of qubit "q":')
print(results.histogram(key='initial_state'))
print('Sampling of qubit "q" after application of X gate:')
print(results.histogram(key='after_not_gate'))
def test_final_density_matrix_qubit_order():
a, b = cirq.LineQubit.range(2)
np.testing.assert_allclose(
cirq.final_density_matrix([cirq.X(a), cirq.X(b)**0.5],
qubit_order=[a, b]),
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0.5, 0.5j], [0, 0, -0.5j, 0.5]])
np.testing.assert_allclose(
cirq.final_density_matrix([cirq.X(a), cirq.X(b)**0.5],
qubit_order=[b, a]),
[[0, 0, 0, 0], [0, 0.5, 0, 0.5j], [0, 0, 0, 0], [0, -0.5j, 0, 0.5]])
np.testing.assert_allclose(
cirq.final_density_matrix([cirq.X(a), cirq.X(b)**0.5],
qubit_order=[b, a],
noise=cirq.ConstantQubitNoiseModel(
cirq.amplitude_damp(1.0))),
[[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])
