Add the ability to customize error gates for depolarizing channel (#254)

This change adds an additional parameter to customize the list
of gates that can be added as potential error gates at each
moment.  Each gate will have its "half_turns" parameter
overwritten by a parameterized value.

Author: dstrain115

cirq/contrib/jobs/depolarizer_channel.py

@@ -15,6 +15,7 @@
 """Error simulator that adds randomly activated error gates after every moment.
 """
 
+import copy
 import numpy as np
 
 from cirq.circuits.circuit import Circuit
@@ -33,8 +34,11 @@ class DepolarizerChannel(object):
     noise by decohering random qubits at each step.  This transform
     is intended only for classical simulations only.
 
-    This class currently only supports adding a Pauli-Z gate at
-    each step.
+    This class currently defaults to adding a Pauli-Z gate at
+    each step but the gate set to add is configurable.  Note that
+    all gates must be XmonGates or have a half_turns parameter
+    that will be overwritten by this class with a parameterized
+    value.
 
     If the job already contains a parameter sweep, this will create
     the error sweep as a cartesian product (i.e. a "factor") of the
@@ -45,14 +49,17 @@ class DepolarizerChannel(object):
     Attributes:
         probability: Probability of a qubit being affected in a given moment
         realizations: Number of simulations to create.
+        depolarizing_gates: A list of XmonGates to include at every moment.
     """
 
     # Prefix for symbols related to error simulation
     _parameter_name = 'error_parameter'
 
-    def __init__(self, probability=0.001, realizations=1):
+    def __init__(self, probability=0.001, realizations=1,
+                 depolarizing_gates=(xmon_gates.ExpZGate(),)):
         self.p = probability
         self.realizations = realizations
+        self.depolarizing_gates = depolarizing_gates
 
     def transform_job(self, job):
         """Creates a new job object with depolarizing channel.
@@ -95,21 +102,23 @@ def transform_job(self, job):
         for moment in circuit.moments:
             moments.append(moment)
 
-            error_gates = []
-            for q in qubit_list:
-                errors = np.random.random(self.realizations) < self.p
-                if any(errors):
-                    key = self._parameter_name + str(error_number)
-                    error_gates.append(xmon_gates.ExpZGate(
-                        half_turns=Symbol(key)).on(q))
-                    error_sweep += Points(key, list(errors * 1.0))
-                    error_number += 1
-
-            if error_gates:
-                moments.append(Moment(error_gates))
+            for gate in self.depolarizing_gates:
+                error_gates = []
+                for q in qubit_list:
+                    errors = np.random.random(self.realizations) < self.p
+                    if any(errors):
+                        key = self._parameter_name + str(error_number)
+                        new_error_gate = copy.deepcopy(gate)
+                        new_error_gate.half_turns = Symbol(key)
+                        error_gates.append(new_error_gate.on(q))
+                        error_sweep += Points(key, list(errors * 1.0))
+                        error_number += 1
+
+                if error_gates:
+                    moments.append(Moment(error_gates))
 
         sweep = job.sweep
-        if len(error_sweep):
+        if error_sweep:
             sweep *= error_sweep
 
         return Job(Circuit(moments), sweep, job.repetitions)

cirq/contrib/jobs/depolarizer_channel_test.py

@@ -55,6 +55,36 @@ def test_depolarizer_all_errors():
     assert allerrors.transform_job(cnot) == cnot_then_z
 
 
+def test_depolarizer_different_gate():
+    q1 = ops.QubitId()
+    q2 = ops.QubitId()
+    cnot = Job(circuits.Circuit([
+        circuits.Moment([ops.CNOT(q1, q2)]),
+        ]))
+    allerrors = DepolarizerChannel(probability=1.0, depolarizing_gates=
+                                   [xmon_gates.ExpZGate(),
+                                    xmon_gates.ExpWGate()])
+    p0 = Symbol(DepolarizerChannel._parameter_name + '0')
+    p1 = Symbol(DepolarizerChannel._parameter_name + '1')
+    p2 = Symbol(DepolarizerChannel._parameter_name + '2')
+    p3 = Symbol(DepolarizerChannel._parameter_name + '3')
+
+    error_sweep = (Points(p0.name, [1.0]) + Points(p1.name, [1.0])
+                   + Points(p2.name, [1.0]) + Points(p3.name, [1.0]))
+
+    cnot_then_z = Job(
+        circuits.Circuit([
+            circuits.Moment([ops.CNOT(q1, q2)]),
+            circuits.Moment([xmon_gates.ExpZGate(half_turns=p0).on(q1),
+                             xmon_gates.ExpZGate(half_turns=p1).on(q2)]),
+            circuits.Moment([xmon_gates.ExpWGate(half_turns=p2).on(q1),
+                             xmon_gates.ExpWGate(half_turns=p3).on(q2)])
+        ]),
+        cnot.sweep * error_sweep)
+
+    assert allerrors.transform_job(cnot) == cnot_then_z
+
+
 def test_depolarizer_multiple_realizations():
     q1 = ops.QubitId()
     q2 = ops.QubitId()