fix spelling mistake: invertable -> invertible (#276)

Author: kevinsung

cirq/__init__.py

@@ -91,7 +91,7 @@
     H,
     HGate,
     InterchangeableQubitsGate,
-    inverse_of_invertable_op_tree,
+    inverse_of_invertible_op_tree,
     KnownMatrixGate,
     MeasurementGate,
     NamedQubit,

cirq/google/decompositions.py

@@ -213,7 +213,7 @@ def controlled_op_to_native_gates(
         del u_gates[-1]
 
     ops_before = [gate(target) for gate in u_gates]
-    ops_after = ops.inverse_of_invertable_op_tree(ops_before)
+    ops_after = ops.inverse_of_invertible_op_tree(ops_before)
     effect = ops.CZ(control, target) ** (cmath.phase(z_phase) / math.pi)
     kickback = ops.Z(control) ** (cmath.phase(global_phase) / math.pi)
 

cirq/ops/__init__.py

@@ -64,6 +64,6 @@
     QubitId,
 )
 from cirq.ops.reversible_composite_gate import (
-    inverse_of_invertable_op_tree,
+    inverse_of_invertible_op_tree,
     ReversibleCompositeGate,
 )

cirq/ops/reversible_composite_gate.py

@@ -38,13 +38,13 @@ def _reverse_operation(operation: raw_types.Operation,
     return raw_types.Operation(gate.inverse(), operation.qubits)
 
 
-def inverse_of_invertable_op_tree(root: op_tree.OP_TREE,
+def inverse_of_invertible_op_tree(root: op_tree.OP_TREE,
                                   extensions: Extensions = Extensions()
                                   ) -> op_tree.OP_TREE:
     """Generates OP_TREE inverses.
 
     Args:
-        root: An operation tree containing only invertable operations.
+        root: An operation tree containing only invertible operations.
         extensions: For caller-provided implementations of gate inverses.
 
     Returns:
@@ -76,5 +76,5 @@ def inverse(self) -> ReversibleCompositeGate:
         return self.forward_form
 
     def default_decompose(self, qubits):
-        return inverse_of_invertable_op_tree(
+        return inverse_of_invertible_op_tree(
             self.forward_form.default_decompose(qubits))

cirq/ops/reversible_composite_gate_test.py

@@ -36,9 +36,9 @@ def __hash__(self):
         return hash((_FlipGate, self.val))
 
 
-def test_inverse_of_invertable_op_tree():
+def test_inverse_of_invertible_op_tree():
     def rev_freeze(root):
-        return ops.freeze_op_tree(ops.inverse_of_invertable_op_tree(root))
+        return ops.freeze_op_tree(ops.inverse_of_invertible_op_tree(root))
 
     operations = [
         ops.Operation(_FlipGate(i), [ops.NamedQubit(str(i))])