merge develop

juangmendoza19 · juangmendoza19 · commit 3c8de56044dd · 2025-06-23T15:36:39.000-06:00
diff --git a/pygsti/circuits/circuitstructure.py b/pygsti/circuits/circuitstructure.py
@@ -719,16 +719,6 @@ def _encodeval(typ, val):
                                           if (self.circuit_weights is not None) else None)
                       })
 
-        #state['plaquette_types'] = XXX
-        #state['datacols'] = {
-        #    'Circuit': [circuits]
-        #    'PlaquetteX':
-        #    'PlaquetteY':
-        #    'X':
-        #    'Y':
-        #    'weight':
-        #    # additional circuits have sentinels for Plaquette coords?
-
         return state
 
     @classmethod
diff --git a/pygsti/circuits/gstcircuits.py b/pygsti/circuits/gstcircuits.py
@@ -544,7 +544,11 @@ def add_to_plaquettes(pkey_dict, plaquette_dict, base_circuit, maxlen, germ, pow
         unindexed = filter_ds(lgst_list, dscheck, missing_lgst)
         lsgst_structs.append(
             _PlaquetteGridCircuitStructure({}, [], germs, "L", "germ", unindexed, op_label_aliases,
-                                           circuit_weights_dict=None, additional_circuits_location='start', name=None))
+                                           circuit_weights_dict=None, additional_circuits_location='start', name=None)).copy() #HACK
+        #TODO: Track bug where the ordering of the _circuit attribute of the 
+        #PlaquetteGridCircuitStructure is somehow changing after copying compared
+        #to how it is constructed here. The hack of bug is meant to mitigate this behavior
+        #by copying the structure ahead of time (the ordering appears to be stable with multiple copies).  
 
     for i, maxLen in enumerate(max_lengths):
 
@@ -634,7 +638,12 @@ def add_to_plaquettes(pkey_dict, plaquette_dict, base_circuit, maxlen, germ, pow
         lsgst_structs.append(
             _PlaquetteGridCircuitStructure({pkey[base]:plaq for base, plaq in plaquettes.items()},
                                            maxLens, germs, "L", "germ", unindexed, op_label_aliases,
-                                           circuit_weights_dict=None, additional_circuits_location='start', name=None))
+                                           circuit_weights_dict=None, additional_circuits_location='start', name=None).copy()) #HACK
+        #TODO: Track bug where the ordering of the _circuit attribute of the 
+        #PlaquetteGridCircuitStructure is somehow changing after copying compared
+        #to how it is constructed here. The hack of bug is meant to mitigate this behavior
+        #by copying the structure ahead of time (the ordering appears to be stable with multiple copies).
+        
         tot_circuits += len(lsgst_structs[-1])  # only relevant for non-nested case
 
     if nest:  # then totStrs computation about overcounts -- just take string count of final stage
diff --git a/pygsti/modelmembers/povms/__init__.py b/pygsti/modelmembers/povms/__init__.py
@@ -299,7 +299,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.
@@ -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,45 +420,46 @@ 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):
-    
+                def calc_physical_subspace(dense_ideal_povm, epsilon = 1e-4):
+
+                    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)
                     
                     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]
-                    #assert num_errgens >= povm.num_params, "POVM has too many elements, error generator parameterization is not possible"
-
-                    ideal_vec = _np.zeros(num_errgens)
+                    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))
-                    
-                    for i in range(len(ideal_vec)):
-                        new_vec = ideal_vec.copy()
+                    new_vec = _np.zeros(num_errgens)
+                    for i in range(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, full_matrices=False)
+
+                    #Only return nontrivial singular vectors
+                    Vt = Vt[S > 1e-13, :].reshape((-1, Vt.shape[1]))
+                    return Vt
+                    
                 
                 phys_directions = calc_physical_subspace(dense_ideal_povm)
 
@@ -482,10 +482,10 @@ 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
+                errgen_vec = _np.linalg.lstsq(phys_directions, soln.x)[0]
                 errorgen.from_vector(errgen_vec)
                 
                 EffectiveExpErrorgen = _IdentityPlusErrorgenOp if lndtype.meta == '1+' else _ExpErrorgenOp
diff --git a/pygsti/modelmembers/states/__init__.py b/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.
@@ -266,28 +266,31 @@ 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):
+                    def calc_physical_subspace(ideal_prep, epsilon = 1e-4):
+                        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
 
-                        _,S,V = _np.linalg.svd(J)
-                        return V[:len(S),]
+                        _,S,Vt = _np.linalg.svd(J, full_matrices=False)
+
+                        #Only return nontrivial singular vectors
+                        Vt = Vt[S > 1e-13, :].reshape((-1, Vt.shape[1]))
+                        return Vt
                         
                     phys_directions = calc_physical_subspace(dense_state)
     
@@ -302,12 +305,12 @@ 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>")
                     
-                    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
@@ -322,7 +325,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)))
diff --git a/pygsti/models/explicitmodel.py b/pygsti/models/explicitmodel.py
@@ -360,12 +360,12 @@ def convert_members_inplace(self, to_type, categories_to_convert='all', labels_t
             for lbl, prep in self.preps.items():
                 if labels_to_convert == 'all' or lbl in labels_to_convert:
                     ideal = ideal_model.preps.get(lbl, None) if (ideal_model is not None) else None
-                    self.preps[lbl] = _state.convert(prep, to_type, self.basis, spam_cp_penalty, ideal, flatten_structure)
+                    self.preps[lbl] = _state.convert(prep, to_type, self.basis, ideal, flatten_structure, cp_penalty=spam_cp_penalty)
         if any([c in categories_to_convert for c in ('all', 'povms')]):
             for lbl, povm in self.povms.items():
                 if labels_to_convert == 'all' or lbl in labels_to_convert:
                     ideal = ideal_model.povms.get(lbl, None) if (ideal_model is not None) else None
-                    self.povms[lbl] = _povm.convert(povm, to_type, self.basis, spam_cp_penalty, ideal, flatten_structure)
+                    self.povms[lbl] = _povm.convert (povm, to_type, self.basis, ideal, flatten_structure, cp_penalty=spam_cp_penalty)
 
         self._clean_paramvec()  # param indices were probabaly updated
         if set_default_gauge_group:
diff --git a/pygsti/models/modelparaminterposer.py b/pygsti/models/modelparaminterposer.py
@@ -70,10 +70,10 @@ def __init__(self, transform_matrix):
         self.full_span_transform_matrix = self.transform_matrix.copy()
         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.
diff --git a/pygsti/tools/internalgates.py b/pygsti/tools/internalgates.py
diff --git a/test/unit/construction/test_stdlists.py b/test/unit/construction/test_stdlists.py
diff --git a/test/unit/objects/test_model.py b/test/unit/objects/test_model.py
