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)