implemented Stefan's PR requests and cleaned up init.py s a little

Author: juangmendoza19

pygsti/modelmembers/povms/__init__.py

@@ -347,7 +347,6 @@ def convert(povm, to_type, basis, cp_penalty=1e-7, ideal_povm=None, flatten_stru
         object from the object passed as input.
     """
 
-    ##TEST CONVERSION BETWEEN LINBLAD TYPES
     to_types = to_type if isinstance(to_type, (tuple, list)) else (to_type,)  # HACK to support multiple to_type values
     error_msgs = {}
 
@@ -421,14 +420,15 @@ def convert(povm, to_type, basis, cp_penalty=1e-7, ideal_povm=None, flatten_stru
                     dense_effects.append(dense_effect.reshape((1,len(dense_effect))))
 
                 dense_povm = _np.concatenate(dense_effects, axis=0)
-                degrees_of_freedom = (dense_ideal_povm.shape[0] - 1) * dense_ideal_povm.shape[1]
-
+                
                 #It is often the case that there are more error generators than physical degrees of freedom in the POVM
                 #We define a function which finds linear comb. of errgens that span these degrees of freedom.
                 #This has been called "the trivial gauge", and this function is meant to avoid it
                 def calc_physical_subspace(dense_ideal_povm, epsilon = 1e-9):
-    
+
+                    degrees_of_freedom = (dense_ideal_povm.shape[0] - 1) * dense_ideal_povm.shape[1]
                     errgen = _LindbladErrorgen.from_error_generator(povm.state_space.dim, parameterization=to_type)
+
                     if degrees_of_freedom > errgen.num_params:
                         warnings.warn("POVM has more degrees of freedom than the available number of parameters, representation in this parameterization is not guaranteed")
                     exp_errgen = _ExpErrorgenOp(errgen)
@@ -437,16 +437,13 @@ def calc_physical_subspace(dense_ideal_povm, epsilon = 1e-9):
                     #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]
-                    #assert num_errgens >= povm.num_params, "POVM has too many elements, error generator parameterization is not possible"
-
-                    ideal_vec = _np.zeros(num_errgens)
 
                     #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))
 
-                    for i in range(len(ideal_vec)):
-                        new_vec = ideal_vec.copy()
+                    for i in range(num_errgens):
+                        new_vec = _np.zeros(num_errgens)
                         new_vec[i] = epsilon
                         exp_errgen.from_vector(new_vec)
                         vectorized_povm = _np.zeros(num_entries)
@@ -482,7 +479,7 @@ def _objfn(v):
                     return _np.linalg.norm(dense_povm - dense_ideal_povm @ proc_matrix) + cp_penalty * sum_of_negative_choi_eigenvalues_gate(proc_matrix, basis)
 
                 soln = _spo.minimize(_objfn, _np.zeros(len(phys_directions), 'd'), method="Nelder-Mead", options={},
-                                        tol=1e-13)  # , callback=callback)
+                                        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

pygsti/modelmembers/states/__init__.py

@@ -266,22 +266,22 @@ def convert(state, to_type, basis, cp_penalty=1e-7, ideal_state=None, flatten_st
                     dense_state = state.to_dense()
                     num_qubits = st.state_space.num_qubits
 
-                    errgen = _LindbladErrorgen.from_error_generator(2**(2*num_qubits), parameterization=to_type)
-                    num_errgens = errgen.num_params
+                    
 
                     #GLND for states suffers from "trivial gauge" freedom. This function identifies
                     #the physical directions to avoid this gauge.
                     def calc_physical_subspace(ideal_prep, epsilon = 1e-9):
+                        errgen = _LindbladErrorgen.from_error_generator(2**(2*num_qubits), parameterization=to_type)
+                        num_errgens = errgen.num_params
 
                         exp_errgen = _ExpErrorgenOp(errgen)
-                        ideal_vec = _np.zeros(num_errgens)
 
                         #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((state.num_params, num_errgens))
 
-                        for i in range(len(ideal_vec)):
-                            new_vec = ideal_vec.copy()
+                        for i in range(num_errgens):
+                            new_vec = _np.zeros(num_errgens)
                             new_vec[i] = epsilon
                             exp_errgen.from_vector(new_vec)
                             J[:,i] = (exp_errgen.to_dense() @ ideal_prep - ideal_prep)[1:]/epsilon
@@ -302,8 +302,8 @@ def _objfn(v):
                         return _np.linalg.norm(proc_matrix @ dense_st - dense_state) + cp_penalty * sum_of_negative_choi_eigenvalues_gate(proc_matrix, basis)
 
                     soln = _spo.minimize(_objfn, _np.zeros(len(phys_directions), 'd'), method="Nelder-Mead", options={},
-                                         tol=1e-13)  # , callback=callback)
-                    #print("DEBUG: opt done: ",soln.success, soln.fun, soln.x)  # REMOVE
+                                         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 exp(errorgen)|ideal> = |state>")
 
@@ -322,7 +322,6 @@ def _objfn(v):
                     return create_from_dmvec(vec, to_type, basis, state.evotype, state.state_space)
 
         except ValueError as e:
-            #_warnings.warn('Failed to convert state to type %s with error: %s' % (to_type, e))
             error_msgs[to_type] = str(e)  # try next to_type
 
     raise ValueError("Could not convert state to to type(s): %s\n%s" % (str(to_types), str(error_msgs)))

test/unit/objects/test_model.py

@@ -741,7 +741,7 @@ def test_bulk_fill_hprobs_with_high_smallness_threshold(self):
     def test_iter_hprobs_by_rectangle(self):
         self.skipTest("TODO should probably warn user?")
 
-class LinbladModelTester(GLNDModelBase, StandardMethodBase, BaseCase):
+class LindbladModelTester(GLNDModelBase, StandardMethodBase, BaseCase):
     pass
 class FullMapSimMethodTester(FullModelBase, SimMethodBase, BaseCase):
     def setUp(self):