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_readout_noise_after_moment():
program = cirq.Circuit()
qubits = cirq.LineQubit.range(3)
program.append([
cirq.H(qubits[0]),
cirq.CNOT(qubits[0], qubits[1]),
cirq.CNOT(qubits[1], qubits[2])
])
program.append(
[
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1'),
cirq.measure(qubits[2], key='q2'),
],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
# Use noise model to generate circuit
depol_noise = ccn.DepolarizingNoiseModel(depol_prob=0.01)
readout_noise = ccn.ReadoutNoiseModel(bitflip_prob=0.05)
noisy_circuit = cirq.Circuit(depol_noise.noisy_moments(program, qubits))
noisy_circuit = cirq.Circuit(
readout_noise.noisy_moments(noisy_circuit, qubits))
# Insert channels explicitly
true_noisy_program = cirq.Circuit()
true_noisy_program.append([cirq.H(qubits[0])])
true_noisy_program.append(
[
cirq.DepolarizingChannel(0.01).on(q).with_tags(ops.VirtualTag())
for q in qubits
],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
true_noisy_program.append([cirq.CNOT(qubits[0], qubits[1])])
true_noisy_program.append(
[
cirq.DepolarizingChannel(0.01).on(q).with_tags(ops.VirtualTag())
for q in qubits
],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
true_noisy_program.append([cirq.CNOT(qubits[1], qubits[2])])
true_noisy_program.append(
[
cirq.DepolarizingChannel(0.01).on(q).with_tags(ops.VirtualTag())
for q in qubits
],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
true_noisy_program.append([
cirq.BitFlipChannel(0.05).on(q).with_tags(ops.VirtualTag())
for q in qubits
])
true_noisy_program.append([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1'),
cirq.measure(qubits[2], key='q2'),
])
assert_equivalent_op_tree(true_noisy_program, noisy_circuit)
def test_per_qubit_combined_noise_from_data():
# Generate the combined noise model from calibration data.
calibration = cirq_google.Calibration(_CALIBRATION_DATA)
noise_model = simple_noise_from_calibration_metrics(
calibration=calibration,
depol_noise=True,
readout_error_noise=True,
readout_decay_noise=True,
)
# Create the circuit and apply the noise model.
qubits = [cirq.GridQubit(0, 0), cirq.GridQubit(0, 1), cirq.GridQubit(1, 0)]
program = cirq.Circuit(
cirq.Moment([cirq.H(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[2])]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1'),
cirq.measure(qubits[2], key='q2'),
]),
)
noisy_circuit = cirq.Circuit(noise_model.noisy_moments(program, qubits))
# Insert channels explicitly to construct expected output.
decay_prob = [
1 - exp(-1 / 0.007), 1 - exp(-1 / 0.008), 1 - exp(-1 / 0.009)
]
expected_program = cirq.Circuit(
cirq.Moment([cirq.H(qubits[0])]),
cirq.Moment([cirq.DepolarizingChannel(DEPOL_001).on(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([
cirq.DepolarizingChannel(DEPOL_001).on(qubits[0]),
cirq.DepolarizingChannel(DEPOL_002).on(qubits[1]),
]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[2])]),
cirq.Moment([
cirq.DepolarizingChannel(DEPOL_001).on(qubits[0]),
cirq.DepolarizingChannel(DEPOL_003).on(qubits[2]),
]),
cirq.Moment([
cirq.AmplitudeDampingChannel(decay_prob[i]).on(qubits[i])
for i in range(3)
]),
cirq.Moment([
cirq.BitFlipChannel(0.004).on(qubits[0]),
cirq.BitFlipChannel(0.005).on(qubits[1]),
cirq.BitFlipChannel(0.006).on(qubits[2]),
]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1'),
cirq.measure(qubits[2], key='q2'),
]),
)
assert_equivalent_op_tree(expected_program, noisy_circuit)
def test_assert_equivalent_op_tree():
assert_equivalent_op_tree([], [])
a = cirq.NamedQubit("a")
assert_equivalent_op_tree([cirq.X(a)], [cirq.X(a)])
assert_equivalent_op_tree(cirq.Circuit([cirq.X(a)]), [cirq.X(a)])
assert_equivalent_op_tree(cirq.Circuit([cirq.X(a)], cirq.Moment()),
[cirq.X(a)])
with pytest.raises(AssertionError):
assert_equivalent_op_tree([cirq.X(a)], [])
def test_per_qubit_depol_noise_from_data():
# Generate the depolarization noise model from calibration data.
calibration = cirq_google.Calibration(_CALIBRATION_DATA)
noise_model = simple_noise_from_calibration_metrics(calibration=calibration, depol_noise=True)
# Create the circuit and apply the noise model.
qubits = [cirq.GridQubit(0, 0), cirq.GridQubit(0, 1), cirq.GridQubit(1, 0)]
program = cirq.Circuit(
cirq.Moment([cirq.H(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[2])]),
cirq.Moment([cirq.Z(qubits[1]).with_tags(cirq.VirtualTag())]),
cirq.Moment(
[
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1'),
cirq.measure(qubits[2], key='q2'),
]
),
)
noisy_circuit = cirq.Circuit(noise_model.noisy_moments(program, qubits))
# Insert channels explicitly to construct expected output.
expected_program = cirq.Circuit(
cirq.Moment([cirq.H(qubits[0])]),
cirq.Moment([cirq.DepolarizingChannel(DEPOL_001).on(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment(
[
cirq.DepolarizingChannel(DEPOL_001).on(qubits[0]),
cirq.DepolarizingChannel(DEPOL_002).on(qubits[1]),
]
),
cirq.Moment([cirq.CNOT(qubits[0], qubits[2])]),
cirq.Moment(
[
cirq.DepolarizingChannel(DEPOL_001).on(qubits[0]),
cirq.DepolarizingChannel(DEPOL_003).on(qubits[2]),
]
),
cirq.Moment([cirq.Z(qubits[1]).with_tags(cirq.VirtualTag())]),
cirq.Moment(
[
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1'),
cirq.measure(qubits[2], key='q2'),
]
),
)
assert_equivalent_op_tree(expected_program, noisy_circuit)
def test_aggregate_decay_noise_after_moment():
program = cirq.Circuit()
qubits = cirq.LineQubit.range(3)
program.append([
cirq.H(qubits[0]),
cirq.CNOT(qubits[0], qubits[1]),
cirq.CNOT(qubits[1], qubits[2])
])
program.append(
[
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1'),
cirq.measure(qubits[2], key='q2'),
],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
# Use noise model to generate circuit
noise_model = ccn.DepolarizingWithDampedReadoutNoiseModel(
depol_prob=0.01, decay_prob=0.02, bitflip_prob=0.05)
noisy_circuit = cirq.Circuit(noise_model.noisy_moments(program, qubits))
# Insert channels explicitly
true_noisy_program = cirq.Circuit()
true_noisy_program.append([cirq.H(qubits[0])])
true_noisy_program.append(
[cirq.DepolarizingChannel(0.01).on(q) for q in qubits],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
true_noisy_program.append([cirq.CNOT(qubits[0], qubits[1])])
true_noisy_program.append(
[cirq.DepolarizingChannel(0.01).on(q) for q in qubits],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
true_noisy_program.append([cirq.CNOT(qubits[1], qubits[2])])
true_noisy_program.append(
[cirq.DepolarizingChannel(0.01).on(q) for q in qubits],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
true_noisy_program.append(
[cirq.AmplitudeDampingChannel(0.02).on(q) for q in qubits])
true_noisy_program.append(
[cirq.BitFlipChannel(0.05).on(q) for q in qubits])
true_noisy_program.append([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1'),
cirq.measure(qubits[2], key='q2'),
])
assert_equivalent_op_tree(true_noisy_program, noisy_circuit)
def test_per_qubit_readout_error_from_data():
# Generate the readout error noise model from calibration data.
calibration = cirq_google.Calibration(_CALIBRATION_DATA)
noise_model = simple_noise_from_calibration_metrics(
calibration=calibration, readout_error_noise=True
)
# Create the circuit and apply the noise model.
qubits = [cirq.GridQubit(0, 0), cirq.GridQubit(0, 1), cirq.GridQubit(1, 0)]
program = cirq.Circuit(
cirq.Moment([cirq.H(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[2])]),
cirq.Moment(
[
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1'),
cirq.measure(qubits[2], key='q2'),
]
),
)
noisy_circuit = cirq.Circuit(noise_model.noisy_moments(program, qubits))
# Insert channels explicitly to construct expected output.
expected_program = cirq.Circuit(
cirq.Moment([cirq.H(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[2])]),
cirq.Moment(
[
cirq.BitFlipChannel(0.004).on(qubits[0]),
cirq.BitFlipChannel(0.005).on(qubits[1]),
cirq.BitFlipChannel(0.006).on(qubits[2]),
]
),
cirq.Moment(
[
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1'),
cirq.measure(qubits[2], key='q2'),
]
),
)
assert_equivalent_op_tree(expected_program, noisy_circuit)
def test_ampl_damping_error():
t1_ns = 200.0
# Create qubits and circuit
qubits = [cirq.LineQubit(0), cirq.LineQubit(1)]
circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.FSimGate(5 * np.pi / 2, np.pi).on_each(qubits)]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
)
# Create noise model from NoiseProperties object with specified noise
prop = NoiseProperties(t1_ns=t1_ns)
noise_model = NoiseModelFromNoiseProperties(prop)
noisy_circuit = cirq.Circuit(noise_model.noisy_moments(circuit, qubits))
# Insert expected channels to circuit
expected_circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment(
[cirq.amplitude_damp(1 - np.exp(-25.0 / t1_ns)).on_each(qubits)]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment(
[cirq.amplitude_damp(1 - np.exp(-25.0 / t1_ns)).on_each(qubits)]),
cirq.Moment([cirq.FSimGate(np.pi / 2, np.pi).on_each(qubits)]),
cirq.Moment(
[cirq.amplitude_damp(1 - np.exp(-12.0 / t1_ns)).on_each(qubits)]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
cirq.Moment([
cirq.amplitude_damp(1 - np.exp(-4000.0 / t1_ns)).on_each(qubits)
]),
)
assert_equivalent_op_tree(expected_circuit, noisy_circuit)
def test_depolarization_error():
# Account for floating point errors
# Needs Cirq issue 3965 to be resolved
pauli_error = 0.09999999999999998
# Create qubits and circuit
qubits = [cirq.LineQubit(0), cirq.LineQubit(1)]
circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.H(qubits[1])]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
)
# Create noise model from NoiseProperties object with specified noise
prop = NoiseProperties(pauli_error=pauli_error)
noise_model = NoiseModelFromNoiseProperties(prop)
noisy_circuit = cirq.Circuit(noise_model.noisy_moments(circuit, qubits))
# Insert expected channels to circuit
expected_circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.depolarize(pauli_error / 3).on_each(qubits)]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.depolarize(pauli_error / 3).on_each(qubits)]),
cirq.Moment([cirq.H(qubits[1])]),
cirq.Moment([cirq.depolarize(pauli_error / 3).on_each(qubits)]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
cirq.Moment([cirq.depolarize(pauli_error / 3).on_each(qubits)]),
)
assert_equivalent_op_tree(expected_circuit, noisy_circuit)
def test_readout_error():
p00 = 0.05
p11 = 0.1
p = p11 / (p00 + p11)
gamma = p11 / p
# Create qubits and circuit
qubits = [cirq.LineQubit(0), cirq.LineQubit(1)]
circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.H(qubits[1])]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
)
# Create noise model from NoiseProperties object with specified noise
prop = NoiseProperties(p00=p00, p11=p11)
noise_model = NoiseModelFromNoiseProperties(prop)
noisy_circuit = cirq.Circuit(noise_model.noisy_moments(circuit, qubits))
# Insert expected channels to circuit
expected_circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.H(qubits[1])]),
cirq.Moment([
cirq.GeneralizedAmplitudeDampingChannel(
p=p, gamma=gamma).on_each(qubits)
]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
)
assert_equivalent_op_tree(expected_circuit, noisy_circuit)
# Create Noise Model with just p00
prop_p00 = NoiseProperties(p00=p00)
noise_model_p00 = NoiseModelFromNoiseProperties(prop_p00)
noisy_circuit_p00 = cirq.Circuit(
noise_model_p00.noisy_moments(circuit, qubits))
# Insert expected channels to circuit
expected_circuit_p00 = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.H(qubits[1])]),
cirq.Moment([
cirq.GeneralizedAmplitudeDampingChannel(p=0.0,
gamma=p00).on_each(qubits)
]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
)
assert_equivalent_op_tree(expected_circuit_p00, noisy_circuit_p00)
# Create Noise Model with just p11
prop_p11 = NoiseProperties(p11=p11)
noise_model_p11 = NoiseModelFromNoiseProperties(prop_p11)
noisy_circuit_p11 = cirq.Circuit(
noise_model_p11.noisy_moments(circuit, qubits))
# Insert expected channels to circuit
expected_circuit_p11 = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.H(qubits[1])]),
cirq.Moment([
cirq.GeneralizedAmplitudeDampingChannel(p=1.0,
gamma=p11).on_each(qubits)
]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
)
assert_equivalent_op_tree(expected_circuit_p11, noisy_circuit_p11)
def test_combined_error():
# Helper function to calculate pauli error from depolarization
def pauli_error_from_depolarization(pauli_error, t1_ns, duration):
t2 = 2 * t1_ns
pauli_error_from_t1 = (1 - np.exp(-duration / t2)) / 2 + (
1 - np.exp(-duration / t1_ns)) / 4
if pauli_error >= pauli_error_from_t1:
return pauli_error - pauli_error_from_t1
return pauli_error
t1_ns = 2000.0
p11 = 0.01
# Account for floating point errors
# Needs Cirq issue 3965 to be resolved
pauli_error = 0.019999999999999962
# Create qubits and circuit
qubits = [cirq.LineQubit(0), cirq.LineQubit(1)]
circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.measure(qubits[0], key='q0')]),
cirq.Moment([cirq.ISwapPowGate().on_each(qubits)]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
)
# Create noise model from NoiseProperties object with specified noise
prop = NoiseProperties(t1_ns=t1_ns, p11=p11, pauli_error=pauli_error)
noise_model = NoiseModelFromNoiseProperties(prop)
with pytest.warns(
RuntimeWarning,
match='Pauli error from T1 decay is greater than total Pauli error'
):
noisy_circuit = cirq.Circuit(noise_model.noisy_moments(
circuit, qubits))
# Insert expected channels to circuit
expected_circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([
cirq.depolarize(
pauli_error_from_depolarization(pauli_error, t1_ns, 25.0) /
3).on_each(qubits)
]),
cirq.Moment(
[cirq.amplitude_damp(1 - np.exp(-25.0 / t1_ns)).on_each(qubits)]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([
cirq.depolarize(
pauli_error_from_depolarization(pauli_error, t1_ns, 25.0) /
3).on_each(qubits)
]),
cirq.Moment(
[cirq.amplitude_damp(1 - np.exp(-25.0 / t1_ns)).on_each(qubits)]),
cirq.Moment([
cirq.GeneralizedAmplitudeDampingChannel(p=1.0,
gamma=p11).on(qubits[0])
]),
cirq.Moment([cirq.measure(qubits[0], key='q0')]),
cirq.Moment([
cirq.depolarize(
pauli_error_from_depolarization(pauli_error, t1_ns, 4000.0) /
3).on_each(qubits)
]),
cirq.Moment([
cirq.amplitude_damp(1 - np.exp(-4000.0 / t1_ns)).on_each(qubits)
]),
cirq.Moment([cirq.ISwapPowGate().on_each(qubits)]),
cirq.Moment([
cirq.depolarize(
pauli_error_from_depolarization(pauli_error, t1_ns, 32.0) /
3).on_each(qubits)
]),
cirq.Moment(
[cirq.amplitude_damp(1 - np.exp(-32.0 / t1_ns)).on_each(qubits)]),
cirq.Moment([
cirq.GeneralizedAmplitudeDampingChannel(p=1.0,
gamma=p11).on_each(qubits)
]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
cirq.Moment([
cirq.depolarize(
pauli_error_from_depolarization(pauli_error, t1_ns, 4000.0) /
3).on_each(qubits)
]),
cirq.Moment([
cirq.amplitude_damp(1 - np.exp(-4000.0 / t1_ns)).on_each(qubits)
]),
)
assert_equivalent_op_tree(expected_circuit, noisy_circuit)
def test_infers_other_methods():
q = cirq.LineQubit(0)
class NoiseModelWithNoisyMomentListMethod(cirq.NoiseModel):
def noisy_moments(self, moments, system_qubits):
result = []
for moment in moments:
if moment.operations:
result.append(
cirq.X(moment.operations[0].qubits[0]).with_tags(
ops.VirtualTag()))
else:
result.append([])
return result
a = NoiseModelWithNoisyMomentListMethod()
assert_equivalent_op_tree(a.noisy_operation(cirq.H(q)),
cirq.X(q).with_tags(ops.VirtualTag()))
assert_equivalent_op_tree(a.noisy_moment(cirq.Moment([cirq.H(q)]), [q]),
cirq.X(q).with_tags(ops.VirtualTag()))
assert_equivalent_op_tree_sequence(
a.noisy_moments(
[cirq.Moment(), cirq.Moment([cirq.H(q)])], [q]),
[[], cirq.X(q).with_tags(ops.VirtualTag())],
)
class NoiseModelWithNoisyMomentMethod(cirq.NoiseModel):
def noisy_moment(self, moment, system_qubits):
return [
y.with_tags(ops.VirtualTag())
for y in cirq.Y.on_each(*moment.qubits)
]
b = NoiseModelWithNoisyMomentMethod()
assert_equivalent_op_tree(b.noisy_operation(cirq.H(q)),
cirq.Y(q).with_tags(ops.VirtualTag()))
assert_equivalent_op_tree(b.noisy_moment(cirq.Moment([cirq.H(q)]), [q]),
cirq.Y(q).with_tags(ops.VirtualTag()))
assert_equivalent_op_tree_sequence(
b.noisy_moments(
[cirq.Moment(), cirq.Moment([cirq.H(q)])], [q]),
[[], cirq.Y(q).with_tags(ops.VirtualTag())],
)
class NoiseModelWithNoisyOperationMethod(cirq.NoiseModel):
def noisy_operation(self, operation: 'cirq.Operation'):
return cirq.Z(operation.qubits[0]).with_tags(ops.VirtualTag())
c = NoiseModelWithNoisyOperationMethod()
assert_equivalent_op_tree(c.noisy_operation(cirq.H(q)),
cirq.Z(q).with_tags(ops.VirtualTag()))
assert_equivalent_op_tree(c.noisy_moment(cirq.Moment([cirq.H(q)]), [q]),
cirq.Z(q).with_tags(ops.VirtualTag()))
assert_equivalent_op_tree_sequence(
c.noisy_moments(
[cirq.Moment(), cirq.Moment([cirq.H(q)])], [q]),
[[], cirq.Z(q).with_tags(ops.VirtualTag())],
)
def assert_equivalent_op_tree_sequence(x: Sequence[cirq.OP_TREE],
y: Sequence[cirq.OP_TREE]):
assert len(x) == len(y)
for a, b in zip(x, y):
assert_equivalent_op_tree(a, b)
