redo inner

lib.py

@@ -65,7 +65,7 @@ class Matrix(object):
         if isinstance(other, Complex):
             return Matrix(self.m * other)
         elif isinstance(other, Matrix):
-            return self.__class__(np.kron(self.m, other.m))
+            return Matrix(np.kron(self.m, other.m))
         raise NotImplementedError
 
     def __rmul__(self, other):
@@ -74,19 +74,6 @@ class Matrix(object):
     def __mul__(self, other):
         return self.__mul_or_kron__(other)
 
-    def __or__(self, other):
-        """Define inner product: <self|other>
-        """
-        m = np.dot(self._conjugate_transpose(), other.m)
-        try:
-            return self.__class__(m)
-        except:
-            try:
-                return other.__class__(m)
-            except:
-                ...
-        return Matrix(m)
-
     def __len__(self):
         return len(self.m)
 
@@ -120,6 +107,10 @@ class Matrix(object):
         """Define outer product |0><0| looks like |0x0| which is 0.x(0)"""
         return self.outer(other)
 
+    def kron(self, other):
+        """Define kronicker product - |0> ⊗ |0> = |00>"""
+        return Matrix(np.kron(self.m, other.m))
+
     def _conjugate_transpose(self):
         return self.m.transpose().conjugate()
 
@@ -267,17 +258,17 @@ class State(Vector):
 
     def length(self):
         """Norm/Length of the vector = sqrt(<self|self>)"""
-        return np.sqrt((self | self).m).item(0)
+        return np.sqrt((self.inner(self)).m).item(0)
 
     def is_orthogonal(self, other):
         """If the inner (dot) product is zero, this vector is orthogonal to other"""
-        return self | other == 0
+        return self.inner(other) == 0
 
     def get_prob(self, j):
         """pr(j) = |<e_j|self>|^2"""
         # j_th basis vector
         e_j = State([[1] if i == int(j) else [0] for i in range(len(self.m))])
-        return np.absolute((e_j | self).m.item(0)) ** 2
+        return np.absolute((e_j.inner(self)).m.item(0)) ** 2
 
     def get_fmt_of_element(self):
         return "{:0" + str(int(np.ceil(np.log2(len(self))))) + "b}"
@@ -830,9 +821,11 @@ class MeasurementOperator(HermitianOperator):
         return state_ct.m.dot(self.m.dot(state.m)).item()
 
 
+m0 = MeasurementOperator.create_from_prob(_0)
+m1 = MeasurementOperator.create_from_prob(_1)
+
+
 def test_measurement_ops():
-    m0 = MeasurementOperator.create_from_prob(Matrix([1, 0]))
-    m1 = MeasurementOperator.create_from_prob(Matrix([0, 1]))
     assert m0 == Matrix([[1, 0],
                          [0, 0]])
     assert m1 == Matrix([[0, 0],
@@ -1113,7 +1106,7 @@ class QuantumCircuit(object):
         if not self.current_quantum_state:
             self.current_quantum_state = step_quantum_state
         else:
-            self.current_quantum_state = step_quantum_state | self.current_quantum_state
+            self.current_quantum_state = step_quantum_state.inner(self.current_quantum_state)
         self.current_step += 1
 
     def run(self):
@@ -1172,7 +1165,7 @@ class QuantumProcessor(object):
         if not self.c_q_state:
             self.c_q_state = step_quantum_state
         else:
-            self.c_q_state = State((step_quantum_state | self.c_q_state).m)
+            self.c_q_state = State((step_quantum_state.inner(self.c_q_state)).m)
         self.c_step += 1
 
     def get_next_step(self):
@@ -1270,4 +1263,10 @@ if __name__ == "__main__":
     test()
     test_quantum_processor()
     test_light()
+
+    # Partial measurement - I want to measure just the first qubit...
+    # TODO - makes sense???
+    # m0_ = m0 * I
+    # post_measurement = b_phi_m.measure_with_op(m0_)
+    # result_0 = post_measurement.measure()
     # test_measure_partial()