applied many PR change requests made by Riley

Author: juangmendoza19

pygsti/modelmembers/povms/__init__.py

@@ -422,7 +422,7 @@ def povm_type_from_op_type(op_type):
     return povm_type_preferences
 
 
-def convert(povm, to_type, basis, cp_penalty=1e-7, ideal_povm=None, flatten_structure=False):
+def convert(povm, to_type, basis, ideal_povm=None, flatten_structure=False, cp_penalty=1e-7):
     """
     TODO: update docstring
     Convert a POVM to a new type of parameterization.
@@ -559,27 +559,26 @@ def calc_physical_subspace(dense_ideal_povm, epsilon = 1e-9):
                     num_errgens = errgen.num_params
                     #TODO: Maybe we can use the num of params instead of number of matrix entries, as some of them are linearly dependent.
                     #i.e E0 completely determines E1 if those are the only two povm elements (E0 + E1 = Identity)
-                    num_entries = dense_ideal_povm.shape[0]*dense_ideal_povm.shape[1]
+                    num_entries = dense_ideal_povm.size
 
                     #Compute the jacobian with respect to the error generators. This will allow us to see which
                     #error generators change the POVM entries
                     J = _np.zeros((num_entries,num_errgens))
-                    
+                    new_vec = _np.zeros(num_errgens)
                     for i in range(num_errgens):
-                        new_vec = _np.zeros(num_errgens)
+                        
                         new_vec[i] = epsilon
                         exp_errgen.from_vector(new_vec)
+                        new_vec[i] = 0
                         vectorized_povm = _np.zeros(num_entries)
                         perturbed_povm = (dense_ideal_povm @ exp_errgen.to_dense() - dense_ideal_povm)/epsilon 
 
-                        perturbed_povm_t = perturbed_povm.transpose()
-                        for j, column in enumerate(perturbed_povm_t):
-                            vectorized_povm[j*len(perturbed_povm_t[0]):(j+1)*len(perturbed_povm_t[0])] = column
+                        vectorized_povm = perturbed_povm.flatten(order='F')
 
-                        J[:,i] = vectorized_povm.transpose()
+                        J[:,i] = vectorized_povm
 
-                    _,S,V = _np.linalg.svd(J)
-                    return V[:len(S),]
+                    _,S,Vt = _np.linalg.svd(J)
+                    return Vt[:len(S),]
 
                 phys_directions = calc_physical_subspace(dense_ideal_povm)
 
@@ -605,7 +604,7 @@ def _objfn(v):
                                         tol=1e-13) 
                 if not soln.success and soln.fun > 1e-6:  # not "or" because success is often not set correctly
                     raise ValueError("Failed to find an errorgen such that <ideal|exp(errorgen) = <effect|")
-                errgen_vec = _np.linalg.pinv(phys_directions)  @ soln.x
+                errgen_vec = _np.linalg.lstsq(phys_directions, soln.x)[0]
                 errorgen.from_vector(errgen_vec)
 
                 EffectiveExpErrorgen = _IdentityPlusErrorgenOp if lndtype.meta == '1+' else _ExpErrorgenOp

pygsti/modelmembers/states/__init__.py

@@ -187,7 +187,7 @@ def state_type_from_op_type(op_type):
     return state_type_preferences
 
 
-def convert(state, to_type, basis, cp_penalty=1e-7, ideal_state=None, flatten_structure=False):
+def convert(state, to_type, basis, ideal_state=None, flatten_structure=False, cp_penalty=1e-7):
     """
     TODO: update docstring
     Convert SPAM vector to a new type of parameterization.
@@ -307,7 +307,7 @@ def _objfn(v):
                     if not soln.success and soln.fun > 1e-6:  # not "or" because success is often not set correctly
                         raise ValueError("Failed to find an errorgen such that exp(errorgen)|ideal> = |state>")
 
-                    errgen_vec = _np.linalg.pinv(phys_directions)  @ soln.x
+                    errgen_vec = _np.linalg.lstsq(phys_directions, soln.x)[0]
                     errorgen.from_vector(errgen_vec)
 
                 EffectiveExpErrorgen = _IdentityPlusErrorgenOp if lndtype.meta == '1+' else _ExpErrorgenOp

pygsti/models/modelparaminterposer.py

@@ -68,10 +68,10 @@ def __init__(self, transform_matrix):
         super().__init__(transform_matrix.shape[1], transform_matrix.shape[0])
 
     def model_paramvec_to_ops_paramvec(self, v):
-        return _np.dot(self.transform_matrix, v)
+        return self.transform_matrix @ v
 
     def ops_paramvec_to_model_paramvec(self, w):
-        return _np.dot(self.inv_transform_matrix, w)
+        return self.inv_transform_matrix @ w
 
     def ops_paramlbls_to_model_paramlbls(self, wl):
         # This can and should be improved later - particularly this will be awful when labels (els of wl) are tuples.

test/unit/objects/test_model.py

@@ -344,14 +344,14 @@ class ThresholdMethodBase(object):
 
     def test_product(self):
         circuit = ('Gx', 'Gy')
-        p1 = np.dot(self.model['Gy'].to_dense(), self.model['Gx'].to_dense())
+        p1 = self.model['Gy'].to_dense() @ self.model['Gx'].to_dense()
         p2 = self.model.sim.product(circuit, scale=False)
         p3, scale = self.model.sim.product(circuit, scale=True)
         self.assertArraysAlmostEqual(p1, p2)
         self.assertArraysAlmostEqual(p1, scale * p3)
 
         circuit = ('Gx', 'Gy', 'Gy')
-        p1 = np.dot(self.model['Gy'].to_dense(), np.dot(self.model['Gy'].to_dense(), self.model['Gx'].to_dense()))
+        p1 = self.model['Gy'].to_dense() @ self.model['Gy'].to_dense() @ self.model['Gx'].to_dense()
         p2 = self.model.sim.product(circuit, scale=False)
         p3, scale = self.model.sim.product(circuit, scale=True)
         self.assertArraysAlmostEqual(p1, p2)
@@ -362,8 +362,8 @@ def test_bulk_product(self):
         gatestring2 = ('Gx', 'Gy', 'Gy')
         circuits = [gatestring1, gatestring2]
 
-        p1 = np.dot(self.model['Gy'].to_dense(), self.model['Gx'].to_dense())
-        p2 = np.dot(self.model['Gy'].to_dense(), np.dot(self.model['Gy'].to_dense(), self.model['Gx'].to_dense()))
+        p1 = self.model['Gy'].to_dense() @ self.model['Gx'].to_dense()
+        p2 = self.model['Gy'].to_dense() @ self.model['Gy'].to_dense() @ self.model['Gx'].to_dense()
 
         bulk_prods = self.model.sim.bulk_product(circuits)
         bulk_prods_scaled, scaleVals = self.model.sim.bulk_product(circuits, scale=True)
@@ -405,15 +405,15 @@ def setUpClass(cls):
         cls.gatestring1 = ('Gx', 'Gy')
         cls.gatestring2 = ('Gx', 'Gy', 'Gy')
         cls._expected_probs = {
-            cls.gatestring1: np.dot(np.transpose(cls._model.povms['Mdefault']['0'].to_dense()),
-                                    np.dot(cls._model['Gy'].to_dense(),
-                                           np.dot(cls._model['Gx'].to_dense(),
-                                                  cls._model.preps['rho0'].to_dense()))).reshape(-1)[0],
-            cls.gatestring2: np.dot(np.transpose(cls._model.povms['Mdefault']['0'].to_dense()),
-                                    np.dot(cls._model['Gy'].to_dense(),
-                                           np.dot(cls._model['Gy'].to_dense(),
-                                                  np.dot(cls._model['Gx'].to_dense(),
-                                                         cls._model.preps['rho0'].to_dense())))).reshape(-1)[0]
+            cls.gatestring1: np.transpose(cls._model.povms['Mdefault']['0'].to_dense()) @
+                                    cls._model['Gy'].to_dense() @
+                                           cls._model['Gx'].to_dense() @
+                                                  cls._model.preps['rho0'].to_dense().reshape(-1)[0],
+            cls.gatestring2: np.transpose(cls._model.povms['Mdefault']['0'].to_dense()) @
+                                    cls._model['Gy'].to_dense() @
+                                           cls._model['Gy'].to_dense() @
+                                                  cls._model['Gx'].to_dense() @
+                                                         cls._model.preps['rho0'].to_dense().reshape(-1)[0]
         }
         # TODO expected dprobs & hprobs
 
@@ -611,12 +611,12 @@ def test_transform(self):
 
         # TODO is this needed?
         for opLabel in cp.operations:
-            self.assertArraysAlmostEqual(cp[opLabel], np.dot(Tinv, np.dot(self.model[opLabel], T)))
+            self.assertArraysAlmostEqual(cp[opLabel], Tinv @ self.model[opLabel] @ T)
         for prepLabel in cp.preps:
-            self.assertArraysAlmostEqual(cp[prepLabel], np.dot(Tinv, self.model[prepLabel]))
+            self.assertArraysAlmostEqual(cp[prepLabel], Tinv @ self.model[prepLabel])
         for povmLabel in cp.povms:
             for effectLabel, eVec in cp.povms[povmLabel].items():
-                self.assertArraysAlmostEqual(eVec, np.dot(np.transpose(T), self.model.povms[povmLabel][effectLabel]))
+                self.assertArraysAlmostEqual(eVec, np.transpose(T) @ self.model.povms[povmLabel][effectLabel])
 
     def test_gpindices(self):
         # Test instrument construction with elements whose gpindices