Speed up clifford simulator by short circuiting on known gates

Author: mpharrigan

cirq/sim/clifford/clifford_simulator.py

@@ -188,7 +188,6 @@ class CliffordTrialResult(simulator.SimulationTrialResult):
     def __init__(self, params: study.ParamResolver,
                  measurements: Dict[str, np.ndarray],
                  final_simulator_state: 'CliffordState') -> None:
-
         super().__init__(params=params,
                          measurements=measurements,
                          final_simulator_state=final_simulator_state)
@@ -331,7 +330,21 @@ def apply_unitary(self, op: 'cirq.Operation'):
 
     def apply_single_qubit_unitary(self, op: 'cirq.Operation'):
         qubit = self.qubit_map[op.qubits[0]]
-        # Handle H natively as optimization.
+        if op.gate == cirq.I:
+            return
+
+        if op.gate == cirq.X:
+            self._apply_X(qubit)
+            return
+
+        if op.gate == cirq.Y:
+            self._apply_Y(qubit)
+            return
+
+        if op.gate == cirq.Z:
+            self._apply_Z(qubit)
+            return
+
         if op.gate == cirq.H:
             self._apply_H(qubit)
             return
@@ -366,14 +379,26 @@ def apply_single_qubit_unitary(self, op: 'cirq.Operation'):
         phase_shift = u[max_idx] / applied_unitary[max_idx]
         self.ch_form.omega *= phase_shift
 
-    def _apply_H(self, qubit: ops.Qid):
+    def _apply_H(self, qubit: int):
         self.tableau._H(qubit)
         self.ch_form._H(qubit)
 
-    def _apply_S(self, qubit: ops.Qid):
+    def _apply_S(self, qubit: int):
         self.tableau._S(qubit)
         self.ch_form._S(qubit)
 
+    def _apply_X(self, qubit: int):
+        self.tableau._X(qubit)
+        self.ch_form._X(qubit)
+
+    def _apply_Z(self, qubit: int):
+        self.tableau._Z(qubit)
+        self.ch_form._Z(qubit)
+
+    def _apply_Y(self, qubit: int):
+        self.tableau._Y(qubit)
+        self.ch_form._Y(qubit)
+
     def perform_measurement(self,
                             qubits: Sequence[ops.Qid],
                             prng: np.random.RandomState,

cirq/sim/clifford/stabilizer_state_ch_form.py

@@ -99,8 +99,8 @@ def inner_product_of_state_and_x(self, x: int) -> Union[float, complex]:
             if y[p]:
                 u ^= self.F[p, :]
                 mu += 2 * (sum(self.M[p, :] & u) % 2)
-        return self.omega * 2**(-sum(self.v) / 2) * 1j**mu * (
-            -1)**sum(self.v & u & self.s) * np.all(self.v | (u == self.s))
+        return (self.omega * 2**(-sum(self.v) / 2) * 1j**mu *
+                (-1)**sum(self.v & u & self.s) * np.all(self.v | (u == self.s)))
 
     def wave_function(self) -> np.ndarray:
         wf = np.zeros(2**self.n, dtype=complex)