Restore deprecated noise models. (#2827)

* Restore deprecated noise models.

* Remove deprecation notice.

* Fix test naming.

cirq/contrib/noise_models/__init__.py

@@ -16,4 +16,6 @@
     DepolarizingNoiseModel,
     ReadoutNoiseModel,
     DampedReadoutNoiseModel,
+    DepolarizingWithReadoutNoiseModel,
+    DepolarizingWithDampedReadoutNoiseModel,
 )

cirq/contrib/noise_models/noise_models.py

@@ -135,6 +135,82 @@ def noisy_moment(self, moment: 'cirq.Moment',
         return moment
 
 
+class DepolarizingWithReadoutNoiseModel(devices.NoiseModel):
+    """DepolarizingNoiseModel with probabilistic bit flips preceding
+    measurement.
+    This simulates readout error.
+    If a circuit contains measurements, they must be in moments that don't
+    also contain gates.
+    """
+
+    def __init__(self, depol_prob: float, bitflip_prob: float):
+        """A depolarizing noise model with readout error.
+        Args:
+            depol_prob: Depolarizing probability.
+            bitflip_prob: Probability of a bit-flip during measurement.
+        """
+        value.validate_probability(depol_prob, 'depol prob')
+        value.validate_probability(bitflip_prob, 'bitflip prob')
+        self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
+        self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
+
+    def noisy_moment(self, moment: 'cirq.Moment',
+                     system_qubits: Sequence['cirq.Qid']):
+        if _homogeneous_moment_is_measurements(moment):
+            return [
+                ops.Moment(self.readout_noise_gate(q) for q in system_qubits),
+                moment,
+            ]
+        return [
+            moment,
+            ops.Moment(self.qubit_noise_gate(q) for q in system_qubits),
+        ]
+
+
+class DepolarizingWithDampedReadoutNoiseModel(devices.NoiseModel):
+    """DepolarizingWithReadoutNoiseModel with T1 decay preceding
+    measurement.
+    This simulates asymmetric readout error. The noise is structured
+    so the T1 decay is applied, then the readout bitflip, then measurement.
+    If a circuit contains measurements, they must be in moments that don't
+    also contain gates.
+    """
+
+    def __init__(
+            self,
+            depol_prob: float,
+            bitflip_prob: float,
+            decay_prob: float,
+    ):
+        """A depolarizing noise model with damped readout error.
+        Args:
+            depol_prob: Depolarizing probability.
+            bitflip_prob: Probability of a bit-flip during measurement.
+            decay_prob: Probability of T1 decay during measurement.
+                Bitflip noise is applied first, then amplitude decay.
+        """
+        value.validate_probability(depol_prob, 'depol prob')
+        value.validate_probability(bitflip_prob, 'bitflip prob')
+        value.validate_probability(decay_prob, 'decay_prob')
+        self.qubit_noise_gate = ops.DepolarizingChannel(depol_prob)
+        self.readout_noise_gate = ops.BitFlipChannel(bitflip_prob)
+        self.readout_decay_gate = ops.AmplitudeDampingChannel(decay_prob)
+
+    def noisy_moment(self, moment: 'cirq.Moment',
+                     system_qubits: Sequence['cirq.Qid']):
+        if _homogeneous_moment_is_measurements(moment):
+            return [
+                ops.Moment(self.readout_decay_gate(q) for q in system_qubits),
+                ops.Moment(self.readout_noise_gate(q) for q in system_qubits),
+                moment
+            ]
+        else:
+            return [
+                moment,
+                ops.Moment(self.qubit_noise_gate(q) for q in system_qubits)
+            ]
+
+
 class PerQubitDepolarizingNoiseModel(devices.NoiseModel):
     """DepolarizingNoiseModel which allows depolarization probabilities to be
     specified separately for each qubit.

cirq/contrib/noise_models/noise_models_test.py

@@ -191,6 +191,96 @@ def test_decay_noise_after_moment():
     _assert_equivalent_op_tree(true_noisy_program, noisy_circuit)
 
 
+# Test the aggregate noise models.
+def test_aggregate_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
+    noise_model = ccn.DepolarizingWithReadoutNoiseModel(depol_prob=0.01,
+                                                        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.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_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)
+
+
 # Fake calibration data object.
 _CALIBRATION_DATA = Merge(
     """