pyGSTi 0.9.12__cp38-cp38-win_amd64.whl → 0.9.13__cp38-cp38-win_amd64.whl

pygsti/algorithms/fiducialpairreduction.py

@@ -153,12 +153,7 @@ def find_sufficient_fiducial_pairs(target_model, prep_fiducials, meas_fiducials,
     #like)
 
     #tol = 0.5 #fraction of expected amplification that must be observed to call a parameter "amplified"
-    if prep_povm_tuples == "first":
-        firstRho = list(target_model.preps.keys())[0]
-        firstPOVM = list(target_model.povms.keys())[0]
-        prep_povm_tuples = [(firstRho, firstPOVM)]
-    prep_povm_tuples = [(_circuits.Circuit((prepLbl,)), _circuits.Circuit((povmLbl,)))
-                        for prepLbl, povmLbl in prep_povm_tuples]
+    prep_povm_tuples = _set_up_prep_POVM_tuples(target_model, prep_povm_tuples, return_meas_dofs = False)
 
     def _get_derivs(length):
         """ Compute all derivative info: get derivative of each `<E_i|germ^exp|rho_j>`
@@ -305,7 +300,7 @@ def find_sufficient_fiducial_pairs(target_model, prep_fiducials, meas_fiducials,
     return listOfAllPairs
 
 def find_sufficient_fiducial_pairs_per_germ(target_model, prep_fiducials, meas_fiducials,
-                                            germs, pre_povm_tuples="first",
+                                            germs, prep_povm_tuples="first",
                                             search_mode="random", constrain_to_tp=True,
                                             n_random=100, min_iterations=None, base_loweig_tol= 1e-1,
                                             seed=None ,verbosity=0, num_soln_returned=1, type_soln_returned='best', retry_for_smaller=True,
@@ -350,7 +345,7 @@ def find_sufficient_fiducial_pairs_per_germ(target_model, prep_fiducials, meas_f
     germs : list of Circuits
         The germ circuits that are repeated to amplify errors.
 
-    pre_povm_tuples : list or "first", optional
+    prep_povm_tuples : list or "first", optional
         A list of `(prepLabel, povmLabel)` tuples to consider when
         checking for completeness.  Usually this should be left as the special
         (and default) value "first", which considers the first prep and POVM
@@ -414,20 +409,9 @@ def find_sufficient_fiducial_pairs_per_germ(target_model, prep_fiducials, meas_f
     """
 
     printer = _baseobjs.VerbosityPrinter.create_printer(verbosity)
-
-    if pre_povm_tuples == "first":
-        firstRho = list(target_model.preps.keys())[0]
-        firstPOVM = list(target_model.povms.keys())[0]
-        pre_povm_tuples = [(firstRho, firstPOVM)]
     
-    #brief intercession to calculate the number of degrees of freedom for the povm.
-    num_effects= len(list(target_model.povms[pre_povm_tuples[0][1]].keys()))
-    dof_per_povm= num_effects-1
-       
-    pre_povm_tuples = [(_circuits.Circuit((prepLbl,)), _circuits.Circuit((povmLbl,)))
-                       for prepLbl, povmLbl in pre_povm_tuples]
-    
-
+    prep_povm_tuples, dof_per_povm = _set_up_prep_POVM_tuples(target_model, prep_povm_tuples, return_meas_dofs = True)
+           
     pairListDict = {}  # dict of lists of 2-tuples: one pair list per germ
     
     if min_iterations is None:
@@ -449,7 +433,8 @@ def find_sufficient_fiducial_pairs_per_germ(target_model, prep_fiducials, meas_f
             gsGerm = target_model.copy()
             gsGerm.set_all_parameterizations("static")
             germMx = gsGerm.sim.product(germ)
-            gsGerm.operations["Ggerm"] = _EigenvalueParamDenseOp(
+            #give this state space labels equal to the line_labels of 
+            gsGerm.operations['Ggerm'] = _EigenvalueParamDenseOp(
                 germMx, True, constrain_to_tp)
 
             printer.show_progress(i, len(germs),
@@ -458,11 +443,12 @@ def find_sufficient_fiducial_pairs_per_germ(target_model, prep_fiducials, meas_f
 
             #Determine which fiducial-pair indices to iterate over
             #initial run
-            candidate_solution_list, bestFirstEval = _get_per_germ_power_fidpairs(prep_fiducials, meas_fiducials, pre_povm_tuples,
+            candidate_solution_list, bestFirstEval = _get_per_germ_power_fidpairs(prep_fiducials, meas_fiducials, prep_povm_tuples,
                                                                     gsGerm, 1, mem_limit,
                                                                     printer, search_mode, seed, n_random, dof_per_povm,
                                                                     min_iterations, base_loweig_tol, candidate_set_seed=None,
-                                                                    num_soln_returned=num_soln_returned, type_soln_returned=type_soln_returned)
+                                                                    num_soln_returned=num_soln_returned, type_soln_returned=type_soln_returned,
+                                                                    germ_circuit=germ)
                                                                    
             #the algorithm isn't guaranteed to actually find the requested number of solutions, so check how many there actually are
             #by checking the length of the list of returned eigenvalues. 
@@ -482,11 +468,12 @@ def find_sufficient_fiducial_pairs_per_germ(target_model, prep_fiducials, meas_f
                 for candidate_solution in candidate_solution_list.values():
                     #now do a seeded run for each of the candidate solutions returned in the initial run:
                     #for these internal runs just return a single solution. 
-                    reducedPairlist, bestFirstEval = _get_per_germ_power_fidpairs(prep_fiducials, meas_fiducials, pre_povm_tuples,
+                    reducedPairlist, bestFirstEval = _get_per_germ_power_fidpairs(prep_fiducials, meas_fiducials, prep_povm_tuples,
                                                                             gsGerm, 1, mem_limit,
                                                                             printer, search_mode, seed, n_random, dof_per_povm,
                                                                             min_iterations, base_loweig_tol, candidate_set_seed=candidate_solution,
-                                                                            num_soln_returned= 1, type_soln_returned='best')
+                                                                            num_soln_returned= 1, type_soln_returned='best',
+                                                                            germ_circuit=germ)
                     #This should now return a dictionary with a single entry. Append that entry to a running list which we'll process at the end.
                     updated_solns.append(list(reducedPairlist.values())[0])
 
@@ -523,7 +510,7 @@ def find_sufficient_fiducial_pairs_per_germ(target_model, prep_fiducials, meas_f
     return pairListDict
     
 def find_sufficient_fiducial_pairs_per_germ_greedy(target_model, prep_fiducials, meas_fiducials,
-                                                germs, pre_povm_tuples="first", constrain_to_tp=True,
+                                                germs, prep_povm_tuples="first", constrain_to_tp=True,
                                                 inv_trace_tol= 10, initial_seed_mode='random',
                                                 evd_tol=1e-10, sensitivity_threshold=1e-10, seed=None ,verbosity=0, check_complete_fid_set=True,
                                                 mem_limit=None):
@@ -567,7 +554,7 @@ def find_sufficient_fiducial_pairs_per_germ_greedy(target_model, prep_fiducials,
     germs : list of Circuits
         The germ circuits that are repeated to amplify errors.
 
-    pre_povm_tuples : list or "first", optional
+    prep_povm_tuples : list or "first", optional
         A list of `(prepLabel, povmLabel)` tuples to consider when
         checking for completeness.  Usually this should be left as the special
         (and default) value "first", which considers the first prep and POVM
@@ -630,17 +617,7 @@ def find_sufficient_fiducial_pairs_per_germ_greedy(target_model, prep_fiducials,
 
     printer = _baseobjs.VerbosityPrinter.create_printer(verbosity)
 
-    if pre_povm_tuples == "first":
-        firstRho = list(target_model.preps.keys())[0]
-        firstPOVM = list(target_model.povms.keys())[0]
-        pre_povm_tuples = [(firstRho, firstPOVM)]
-    
-    #brief intercession to calculate the number of degrees of freedom for the povm.
-    num_effects= len(list(target_model.povms[pre_povm_tuples[0][1]].keys()))
-    dof_per_povm= num_effects-1
-       
-    pre_povm_tuples = [(_circuits.Circuit((prepLbl,)), _circuits.Circuit((povmLbl,)))
-                       for prepLbl, povmLbl in pre_povm_tuples]
+    prep_povm_tuples, dof_per_povm = _set_up_prep_POVM_tuples(target_model, prep_povm_tuples, return_meas_dofs=True)
 
     pairListDict = {}  # dict of lists of 2-tuples: one pair list per germ
     
@@ -667,12 +644,13 @@ def find_sufficient_fiducial_pairs_per_germ_greedy(target_model, prep_fiducials,
 
             #Determine which fiducial-pair indices to iterate over
             #initial run
-            candidate_solution_list, best_score = _get_per_germ_power_fidpairs_greedy(prep_fiducials, meas_fiducials, pre_povm_tuples,
+            candidate_solution_list, best_score = _get_per_germ_power_fidpairs_greedy(prep_fiducials, meas_fiducials, prep_povm_tuples,
                                                                     gsGerm, 1, mem_limit,
                                                                     printer, seed, dof_per_povm,
                                                                     inv_trace_tol, initial_seed_mode=initial_seed_mode,
                                                                     check_complete_fid_set=check_complete_fid_set, evd_tol=evd_tol,
-                                                                    sensitivity_threshold=sensitivity_threshold)
+                                                                    sensitivity_threshold=sensitivity_threshold,
+                                                                    germ_circuit= germ)
             
             #print some output about the minimum eigenvalue acheived.
             printer.log('Score Achieved: ' + str(best_score), 2)
@@ -691,7 +669,7 @@ def find_sufficient_fiducial_pairs_per_germ_greedy(target_model, prep_fiducials,
 
 def find_sufficient_fiducial_pairs_per_germ_power(target_model, prep_fiducials, meas_fiducials,
                                                   germs, max_lengths,
-                                                  pre_povm_tuples="first",
+                                                  prep_povm_tuples="first",
                                                   search_mode="random", constrain_to_tp=True,
                                                   trunc_scheme="whole germ powers",
                                                   n_random=100, min_iterations=None, base_loweig_tol= 1e-1, seed=None,
@@ -746,7 +724,7 @@ def find_sufficient_fiducial_pairs_per_germ_power(target_model, prep_fiducials,
     max_lengths: list of int
         The germ powers (number of repetitions) to be used to amplify errors.
 
-    pre_povm_tuples : list or "first", optional
+    prep_povm_tuples : list or "first", optional
         A list of `(prepLabel, povmLabel)` tuples to consider when
         checking for completeness.  Usually this should be left as the special
         (and default) value "first", which considers the first prep and POVM
@@ -805,16 +783,9 @@ def find_sufficient_fiducial_pairs_per_germ_power(target_model, prep_fiducials,
     
     printer = _baseobjs.VerbosityPrinter.create_printer(verbosity)
 
-    if pre_povm_tuples == "first":
-        firstRho = list(target_model.preps.keys())[0]
-        firstPOVM = list(target_model.povms.keys())[0]
-        pre_povm_tuples = [(firstRho, firstPOVM)]
-
-    pre_povm_tuples = [(_circuits.Circuit((prepLbl,)), _circuits.Circuit((povmLbl,)))
-                       for prepLbl, povmLbl in pre_povm_tuples]
+    prep_povm_tuples = _set_up_prep_POVM_tuples(target_model, prep_povm_tuples, return_meas_dofs=False)
+    
     pairListDict = {}  # dict of lists of 2-tuples: one pair list per germ
-    low_eigvals = {}
-    #base_loweig_threshold = 1e-2  # HARDCODED
     
     #Check whether the user has passed in a candidate set as a seed from a previous run of
     #per-germ FPR.
@@ -881,11 +852,11 @@ def find_sufficient_fiducial_pairs_per_germ_power(target_model, prep_fiducials,
             else:
                 candidate_set_seed= None
             
-            goodPairList, _ = _get_per_germ_power_fidpairs(prep_fiducials, meas_fiducials, pre_povm_tuples,
+            goodPairList, _ = _get_per_germ_power_fidpairs(prep_fiducials, meas_fiducials, prep_povm_tuples,
                                                                 gsGerm, power, mem_limit,
                                                                 printer, search_mode, seed, n_random,
                                                                 min_iterations, base_loweig_tol, candidate_set_seed,
-                                                                num_soln_returned=1, type_soln_returned='best')
+                                                                num_soln_returned=1, type_soln_returned='best', germ_circuit = germ)
                                                                 
             #This should now return a dictionary with a single entry. pull that entry out.
             goodPairList= list(goodPairList.values())[0]
@@ -900,7 +871,7 @@ def find_sufficient_fiducial_pairs_per_germ_power(target_model, prep_fiducials,
     return pairListDict
 
 def test_fiducial_pairs(fid_pairs, target_model, prep_fiducials, meas_fiducials, germs,
-                        test_lengths=(256, 2048), pre_povm_tuples="first", tol=0.75,
+                        test_lengths=(256, 2048), prep_povm_tuples="first", tol=0.75,
                         verbosity=0, mem_limit=None):
     """
     Tests a set of global or per-germ fiducial pairs.
@@ -936,7 +907,7 @@ def test_fiducial_pairs(fid_pairs, target_model, prep_fiducials, meas_fiducials,
         A tuple of integers specifying the germ-power lengths to use when
         checking for amplificational completeness.
 
-    pre_povm_tuples : list or "first", optional
+    prep_povm_tuples : list or "first", optional
         A list of `(prepLabel, povmLabel)` tuples to consider when
         checking for completeness.  Usually this should be left as the special
         (and default) value "first", which considers the first prep and POVM
@@ -958,12 +929,7 @@ def test_fiducial_pairs(fid_pairs, target_model, prep_fiducials, meas_fiducials,
     """
     printer = _baseobjs.VerbosityPrinter.create_printer(verbosity)
 
-    if pre_povm_tuples == "first":
-        firstRho = list(target_model.preps.keys())[0]
-        firstPOVM = list(target_model.povms.keys())[0]
-        pre_povm_tuples = [(firstRho, firstPOVM)]
-    pre_povm_tuples = [(_circuits.Circuit((prepLbl,)), _circuits.Circuit((povmLbl,)))
-                       for prepLbl, povmLbl in pre_povm_tuples]
+    prep_povm_tuples = _set_up_prep_POVM_tuples(target_model, prep_povm_tuples, return_meas_dofs=False)
 
     def _get_derivs(length):
         """ Compute all derivative info: get derivative of each `<E_i|germ^exp|rho_j>`
@@ -975,7 +941,7 @@ def test_fiducial_pairs(fid_pairs, target_model, prep_fiducials, meas_fiducials,
             pairList = fid_pairs[germ] if isinstance(fid_pairs, dict) else fid_pairs
             circuits += _gsc.create_circuits("pp[0]+p[0]+expGerm+p[1]+pp[1]",
                                              p=[(prep_fiducials[i], meas_fiducials[j]) for i, j in pairList],
-                                             pp=pre_povm_tuples, expGerm=expGerm, order=['p', 'pp'])
+                                             pp=prep_povm_tuples, expGerm=expGerm, order=['p', 'pp'])
         circuits = _remove_duplicates(circuits)
 
         resource_alloc = _baseobjs.ResourceAllocation(comm=None, mem_limit=mem_limit)
@@ -1023,10 +989,11 @@ def test_fiducial_pairs(fid_pairs, target_model, prep_fiducials, meas_fiducials,
 
 
 # Helper function for per_germ and per_germ_power FPR
-def _get_per_germ_power_fidpairs(prep_fiducials, meas_fiducials, pre_povm_tuples,
+def _get_per_germ_power_fidpairs(prep_fiducials, meas_fiducials, prep_povm_tuples,
                                  gsGerm, power, mem_limit, printer, search_mode, seed, n_random, dof_per_povm,
                                  min_iterations=1, lowest_eigenval_tol=1e-1,
-                                 candidate_set_seed=None, num_soln_returned=1, type_soln_returned='best'):
+                                 candidate_set_seed=None, num_soln_returned=1, type_soln_returned='best',
+                                 germ_circuit = None):
     #Get dP-matrix for full set of fiducials, where
     # P_ij = <E_i|germ^exp|rho_j>, i = composite EVec & fiducial index,
     #   j is similar, and derivs are wrt the "eigenvalues" of the germ
@@ -1048,17 +1015,18 @@ def _get_per_germ_power_fidpairs(prep_fiducials, meas_fiducials, pre_povm_tuples
     
     min_pairs_needed= ceil((gsGerm.num_params/(nPossiblePairs*dof_per_povm))*nPossiblePairs)
     printer.log('Minimum Number of Pairs Needed for this Germ: %d'%(min_pairs_needed), 2)    
+    line_labels = germ_circuit.line_labels if germ_circuit is not None else 'auto'
 
     lst = _gsc.create_circuits(
         "pp[0]+f0+germ*power+f1+pp[1]", f0=prep_fiducials, f1=meas_fiducials,
-        germ=_circuits.Circuit('Ggerm'), pp=pre_povm_tuples, power=power,
+        germ=_circuits.Circuit(['Ggerm'], line_labels=line_labels), pp=prep_povm_tuples, power=power,
         order=('f0', 'f1', 'pp'))
 
     resource_alloc = _baseobjs.ResourceAllocation(comm=None, mem_limit=mem_limit)
     layout = gsGerm.sim.create_layout(lst, None, resource_alloc, array_types=('ep',), verbosity=0)
 
     elIndicesForPair = [[] for i in range(len(prep_fiducials) * len(meas_fiducials))]
-    nPrepPOVM = len(pre_povm_tuples)
+    nPrepPOVM = len(prep_povm_tuples)
     for k in range(len(prep_fiducials) * len(meas_fiducials)):
         for o in range(k * nPrepPOVM, (k + 1) * nPrepPOVM):
             # "original" indices into lst for k-th fiducial pair
@@ -1249,7 +1217,6 @@ def _get_per_germ_power_fidpairs(prep_fiducials, meas_fiducials, pre_povm_tuples
                 # subset of the total fiducial pairs.
                 elementIndicesToTest = _np.concatenate([elIndicesForPair[i] for i in pairIndicesToTest])
                 dP = _np.take(dPall, elementIndicesToTest, axis=0)  # subset_of_num_elements x num_params
-                #print('Rank of candidate set: ', _np.linalg.matrix_rank(dP))
                 
                 spectrum = _np.abs(_np.linalg.eigvalsh(_np.dot(dP, dP.T)))
                 current_rank= _np.count_nonzero(spectrum>1e-10)
@@ -1282,8 +1249,8 @@ def _get_per_germ_power_fidpairs(prep_fiducials, meas_fiducials, pre_povm_tuples
                                 try:
                                     bestPairs.pop(bestFirstEval[-1])
                                 except KeyError as err:
-                                    print("trying to drop the element from bestPairs with key: ", bestFirstEval[-1])
-                                    print("current keys in this dictionary: ", bestPairs.keys())
+                                    printer.log(f"Trying to drop the element from bestPairs with key: {bestFirstEval[-1]}", 3)
+                                    printer.log(f"Current keys in this dictionary: {bestPairs.keys()}", 3)
                                     
                                     #This seems to be happening when there are multiple entries with virtually
                                     #identical values for the keys. 
@@ -1328,10 +1295,11 @@ def _get_per_germ_power_fidpairs(prep_fiducials, meas_fiducials, pre_povm_tuples
 # This version uses a greedy style algorithm and an
 # alternative objective function which leverages the performance enhancements
 # utilized for the germ selection algorithm using low-rank updates.
-def _get_per_germ_power_fidpairs_greedy(prep_fiducials, meas_fiducials, pre_povm_tuples,
+def _get_per_germ_power_fidpairs_greedy(prep_fiducials, meas_fiducials, prep_povm_tuples,
                                  gsGerm, power, mem_limit, printer, seed, dof_per_povm,
                                  inv_trace_tol=10, initial_seed_mode= 'random',
-                                 check_complete_fid_set= True, evd_tol=1e-10, sensitivity_threshold= 1e-10):
+                                 check_complete_fid_set= True, evd_tol=1e-10, sensitivity_threshold= 1e-10,
+                                 germ_circuit = None):
     #Get dP-matrix for full set of fiducials, where
     # P_ij = <E_i|germ^exp|rho_j>, i = composite EVec & fiducial index,
     #   j is similar, and derivs are wrt the "eigenvalues" of the germ
@@ -1352,17 +1320,18 @@ def _get_per_germ_power_fidpairs_greedy(prep_fiducials, meas_fiducials, pre_povm
     
     min_pairs_needed= ceil((gsGerm.num_params/(nPossiblePairs*dof_per_povm))*nPossiblePairs)
     printer.log('Minimum Number of Pairs Needed for this Germ: %d'%(min_pairs_needed), 2)
-    
+    line_labels = germ_circuit.line_labels if germ_circuit is not None else 'auto'
+
     lst = _gsc.create_circuits(
         "pp[0]+f0+germ*power+f1+pp[1]", f0=prep_fiducials, f1=meas_fiducials,
-        germ=_circuits.Circuit('Ggerm'), pp=pre_povm_tuples, power=power,
+        germ=_circuits.Circuit(['Ggerm'], line_labels=line_labels), pp=prep_povm_tuples, power=power,
         order=('f0', 'f1', 'pp'))
 
     resource_alloc = _baseobjs.ResourceAllocation(comm=None, mem_limit=mem_limit)
     layout = gsGerm.sim.create_layout(lst, None, resource_alloc, array_types=('ep',), verbosity=0)
 
     elIndicesForPair = [[] for i in range(len(prep_fiducials) * len(meas_fiducials))]
-    nPrepPOVM = len(pre_povm_tuples)
+    nPrepPOVM = len(prep_povm_tuples)
     for k in range(len(prep_fiducials) * len(meas_fiducials)):
         for o in range(k * nPrepPOVM, (k + 1) * nPrepPOVM):
             # "original" indices into lst for k-th fiducial pair
@@ -1586,7 +1555,7 @@ def filter_useless_fid_pairs(fiducial_indices, element_map, complete_jacobian, s
 #about the amplificational properties of the germ set as a whole.
 
 def find_sufficient_fiducial_pairs_per_germ_global(target_model, prep_fiducials, meas_fiducials,
-                                                   germ_vector_spanning_set=None, germs=None, pre_povm_tuples="first",
+                                                   germ_vector_spanning_set=None, germs=None, prep_povm_tuples="first",
                                                    mem_limit=None, inv_trace_tol= 10, initial_seed_mode='greedy',
                                                    evd_tol=1e-10, seed=None ,verbosity=0, float_type = _np.cdouble,
                                                    germ_set_spanning_kwargs = None, precomputed_jacobians = None):
@@ -1633,7 +1602,7 @@ def find_sufficient_fiducial_pairs_per_germ_global(target_model, prep_fiducials,
         If passed in and germ_vector_spanning_set is None then we'll use this
         in the calculation of the germ vector spanning set.
 
-    pre_povm_tuples : list or "first", optional
+    prep_povm_tuples : list or "first", optional
         A list of `(prepLabel, povmLabel)` tuples to consider when
         checking for completeness.  Usually this should be left as the special
         (and default) value "first", which considers the first prep and POVM
@@ -1711,17 +1680,7 @@ def find_sufficient_fiducial_pairs_per_germ_global(target_model, prep_fiducials,
                                                                  verbosity=verbosity,
                                                                  **used_kwargs)
 
-    if pre_povm_tuples == "first":
-        firstRho = list(target_model.preps.keys())[0]
-        firstPOVM = list(target_model.povms.keys())[0]
-        pre_povm_tuples = [(firstRho, firstPOVM)]
-    
-    #brief intercession to calculate the number of degrees of freedom for the povm.
-    num_effects= len(list(target_model.povms[pre_povm_tuples[0][1]].keys()))
-    dof_per_povm= num_effects-1
-       
-    pre_povm_tuples = [(_circuits.Circuit((prepLbl,)), _circuits.Circuit((povmLbl,)))
-                       for prepLbl, povmLbl in pre_povm_tuples]
+    prep_povm_tuples, dof_per_povm = _set_up_prep_POVM_tuples(target_model, prep_povm_tuples, return_meas_dofs=True)
 
     pairListDict = {}  # dict of lists of 2-tuples: one pair list per germ
     
@@ -1733,7 +1692,7 @@ def find_sufficient_fiducial_pairs_per_germ_global(target_model, prep_fiducials,
     printer.log("------  Per Germ Global Fiducial Pair Reduction --------")
     with printer.progress_logging(1):
         for i, (germ, germ_vector_list) in enumerate(germ_vector_spanning_set.items()):
-            candidate_solution_list, best_score = get_per_germ_fid_pairs_global(prep_fiducials, meas_fiducials, pre_povm_tuples,
+            candidate_solution_list, best_score = get_per_germ_fid_pairs_global(prep_fiducials, meas_fiducials, prep_povm_tuples,
                                                                     target_model, germ, germ_vector_list, mem_limit,
                                                                     printer, dof_per_povm, inv_trace_tol, 
                                                                     initial_seed_mode=initial_seed_mode, evd_tol=evd_tol,
@@ -1754,7 +1713,7 @@ def find_sufficient_fiducial_pairs_per_germ_global(target_model, prep_fiducials,
 
     return pairListDict
     
-def get_per_germ_fid_pairs_global(prep_fiducials, meas_fiducials, pre_povm_tuples,
+def get_per_germ_fid_pairs_global(prep_fiducials, meas_fiducials, prep_povm_tuples,
                                  target_model, germ, germ_vector_list, mem_limit, printer, dof_per_povm, 
                                  inv_trace_tol=10, initial_seed_mode= 'greedy', evd_tol=1e-10, 
                                  float_type = _np.cdouble, dprobs_dict = None):                      
@@ -1782,8 +1741,7 @@ def get_per_germ_fid_pairs_global(prep_fiducials, meas_fiducials, pre_povm_tuple
     
     allPairIndices = list(range(nPossiblePairs))
 
-    print('Current Germ: ')
-    print(germ)
+    printer.log(f'Current Germ: {germ}', 2)
     
     printer.log('Number of possible pairs: %d'%(nPossiblePairs), 3)
     
@@ -1797,10 +1755,10 @@ def get_per_germ_fid_pairs_global(prep_fiducials, meas_fiducials, pre_povm_tuple
     #loops over a number of pairs between min_pairs_needed and up to and not including the number of possible pairs
     min_pairs_needed= ceil((num_germ_vecs/(nPossiblePairs*dof_per_povm))*nPossiblePairs)
     printer.log('Minimum Number of Pairs Needed for this Germ: %d'%(min_pairs_needed), 2)
-    
+
     lst = _gsc.create_circuits(
         "pp[0]+f0+germ*power+f1+pp[1]", f0=prep_fiducials, f1=meas_fiducials,
-        germ=germ, pp=pre_povm_tuples, power=1,
+        germ=germ, pp=prep_povm_tuples, power=1,
         order=('f0', 'f1', 'pp'))
     
     printer.log('Constructing Directional Derivatives for Full Fiducial Set' , 2)
@@ -2054,9 +2012,7 @@ def _compute_bulk_directional_ddd_compact(model, circuits, vec_mat, eps,
                 
                 #now calculate the direction derivative matrix.
                 directional_deriv = jac@vec_mat
-                #print('directional deriv shape: ' + str(directional_deriv.shape))
-                direc_deriv_gram = directional_deriv.T@directional_deriv
-                #print('directional deriv gram shape: ' + str(direc_deriv_gram.shape))                                        
+                direc_deriv_gram = directional_deriv.T@directional_deriv                                        
                 #now take twirledDerivDerivDagger and construct its compact EVD.
                 e, U= compact_EVD(direc_deriv_gram, evd_tol)
                 e_list.append(e)
@@ -2117,7 +2073,8 @@ def _make_spam_static(model):
 #write a helper function for precomputing the jacobian dictionaries from bulk_dprobs
 #which can then be passed into the construction of the compactEVD caches.
 
-def compute_jacobian_dicts(model, germs, prep_fiducials, meas_fiducials, pre_povm_tuples = 'first', comm=None, mem_limit=None):
+def compute_jacobian_dicts(model, germs, prep_fiducials, meas_fiducials, prep_povm_tuples = 'first', comm=None, 
+                           mem_limit=None, verbosity = 0):
     """
     Function for precomputing the jacobian dictionaries from bulk_dprobs
     for a model with its SPAM parameters frozen, as needed for certain
@@ -2136,7 +2093,7 @@ def compute_jacobian_dicts(model, germs, prep_fiducials, meas_fiducials, pre_pov
     meas_fiducials : list of Circuits
         A list of measurement fiducial circuits.
         
-    pre_povm_tuples : str or list of tuples (default 'first')
+    prep_povm_tuples : str or list of tuples (default 'first')
         Either a string or list of tuples. When a list of tuples
         these correspond to native state prep and native POVM pairs.
         When the special keyword argument 'first' is passed in the first
@@ -2160,14 +2117,10 @@ def compute_jacobian_dicts(model, germs, prep_fiducials, meas_fiducials, pre_pov
     """
     resource_alloc = _baseobjs.ResourceAllocation(comm= comm, mem_limit = mem_limit)
     
+    printer = _baseobjs.VerbosityPrinter.create_printer(verbosity, comm= comm)
+
     #construct the list of circuits
-    if pre_povm_tuples == "first":
-        firstRho = list(model.preps.keys())[0]
-        firstPOVM = list(model.povms.keys())[0]
-        pre_povm_tuples = [(firstRho, firstPOVM)]
-        
-    pre_povm_tuples = [(_circuits.Circuit((prepLbl,)), _circuits.Circuit((povmLbl,)))
-                       for prepLbl, povmLbl in pre_povm_tuples]
+    prep_povm_tuples = _set_up_prep_POVM_tuples(model, prep_povm_tuples, return_meas_dofs=False)
         
     #freeze the SPAM model parameters:
     static_spam_model = _make_spam_static(model)
@@ -2175,16 +2128,48 @@ def compute_jacobian_dicts(model, germs, prep_fiducials, meas_fiducials, pre_pov
     jacobian_dicts = {}
         
     for germ in germs:       
-        if comm is None or comm.Get_rank() ==0:
-            print('Current germ:', germ, flush=True)
+        printer.log(f'Current germ: {germ}', 1)
          
         lst = _gsc.create_circuits(
             "pp[0]+f0+germ*power+f1+pp[1]", f0=prep_fiducials, f1=meas_fiducials,
-            germ=germ, pp=pre_povm_tuples, power=1,
+            germ=germ, pp=prep_povm_tuples, power=1,
             order=('f0', 'f1', 'pp'))
         
         #calculate the dprobs dictionary in bulk.
         dprobs_dict = static_spam_model.sim.bulk_dprobs(lst, resource_alloc)        
         jacobian_dicts[germ] = dprobs_dict
         
-    return jacobian_dicts
+    return jacobian_dicts
+
+#helper function for configuring the list of circuit tuples needed for prep-POVM pairs used in FPR.
+def _set_up_prep_POVM_tuples(target_model, prep_povm_tuples, return_meas_dofs= False):
+
+    if prep_povm_tuples == "first":
+        firstRho = list(target_model.preps.keys())[0]
+        prep_ssl = [target_model.preps[firstRho].state_space.state_space_labels]
+        firstPOVM = list(target_model.povms.keys())[0]
+        POVM_ssl = [target_model.povms[firstPOVM].state_space.state_space_labels]
+        prep_povm_tuples = [(firstRho, firstPOVM)]
+        #I think using the state space labels for firstRho and firstPOVM as the
+        #circuit labels should work most of the time (new stricter line_label enforcement means
+        # we need to enforce compatibility here), but this might break for
+        #ImplicitModels? Not sure how those handle the state space labels for preps and povms
+        #Time will tell...
+    #if not we still need to extract state space labels for all of these to meet new circuit
+    #label handling requirements.
+    else:
+        prep_ssl = [target_model.preps[lbl_tup[0]].state_space.state_space_labels for lbl_tup in prep_povm_tuples]
+        POVM_ssl = [target_model.povms[lbl_tup[1]].state_space.state_space_labels for lbl_tup in prep_povm_tuples]
+
+    #brief intercession to calculate the number of degrees of freedom for the povm.
+    num_effects= len(list(target_model.povms[prep_povm_tuples[0][1]].keys()))
+    dof_per_povm= num_effects-1
+
+    prep_povm_tuples = [(_circuits.Circuit([prepLbl], line_labels=prep_ssl[i]), 
+                        _circuits.Circuit([povmLbl], line_labels=POVM_ssl[i]))
+                       for i, (prepLbl, povmLbl) in enumerate(prep_povm_tuples)]
+    
+    if return_meas_dofs:
+        return prep_povm_tuples, dof_per_povm
+    else:
+        return prep_povm_tuples

pygsti/algorithms/fiducialselection.py

@@ -409,13 +409,6 @@ def find_fiducials(target_model, omit_identity=True, eq_thresh=1e-6,
         return prepFidList, measFidList    
 
 
-#def bool_list_to_ind_list(boolList):
-#    output = _np.array([])
-#    for i, boolVal in boolList:
-#        if boolVal == 1:
-#            output = _np.append(i)
-#    return output
-
 def xor(*args):
     """
     Implements logical xor function for arbitrary number of inputs.
@@ -2013,7 +2006,23 @@ def create_candidate_fiducial_list(target_model, omit_identity= True, ops_to_omi
         else:
             availableFidList.extend(_circuits.list_random_circuits_onelen(
                 fidOps, fidLength, count, seed=candidate_seed))
-    return availableFidList
+
+    #force the line labels on each circuit to match the state space labels for the target model.
+    #this is suboptimal for many-qubit models, so will probably want to revisit this. #TODO
+    finalFidList = []
+    for ckt in availableFidList:
+        if ckt._static:
+            new_ckt = ckt.copy(editable=True)
+            new_ckt.line_labels = target_model.state_space.state_space_labels
+            new_ckt.done_editing()
+            
+            finalFidList.append(new_ckt)
+        else:
+            ckt.line_labels = target_model.state_space.state_space_labels
+
+            finalFidList.append(ckt)
+        
+    return finalFidList
     
     
     

pygsti/algorithms/gaugeopt.py

@@ -290,7 +290,7 @@ def gaugeopt_custom(model, objective_fn, gauge_group=None,
     gaugeGroupEl = gauge_group.compute_element(x0)  # re-used element for evals
 
     def _call_objective_fn(gauge_group_el_vec, oob_check=False):
-        # Note: oob_check can be True if oob_check_interval>=1 is given to the custom_leastsq below
+        # Note: oob_check can be True if oob_check_interval>=1 is given to the simplish_leastsq below
         gaugeGroupEl.from_vector(gauge_group_el_vec)
         return objective_fn(gaugeGroupEl, oob_check)
 
@@ -309,7 +309,7 @@ def gaugeopt_custom(model, objective_fn, gauge_group=None,
         assert(_call_jacobian_fn is not None), "Cannot use 'ls' method unless jacobian is available"
         ralloc = _baseobjs.ResourceAllocation(comm)  # FUTURE: plumb up a resource alloc object?
         test_f = _call_objective_fn(x0)
-        solnX, converged, msg, _, _, _, _, _ = _opt.custom_leastsq(
+        solnX, converged, msg, _, _, _, _ = _opt.simplish_leastsq(
             _call_objective_fn, _call_jacobian_fn, x0, f_norm2_tol=tol,
             jac_norm_tol=tol, rel_ftol=tol, rel_xtol=tol,
             max_iter=maxiter, resource_alloc=ralloc,