pyGSTi 0.9.12.1__cp38-cp38-win32.whl → 0.9.13__cp38-cp38-win32.whl

{pyGSTi-0.9.12.1.dist-info → pyGSTi-0.9.13.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: false
 Tag: cp38-cp38-win32
 

pygsti/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.9.12.1'
-__version_tuple__ = version_tuple = (0, 9, 12, 1)
+__version__ = version = '0.9.13'
+__version_tuple__ = version_tuple = (0, 9, 13)

pygsti/algorithms/contract.py

@@ -358,7 +358,7 @@ def _contract_to_valid_spam(model, verbosity=0):
 
     # ** assumption: only the first vector element of pauli vectors has nonzero trace
     dummyVec = _np.zeros((model.dim, 1), 'd'); dummyVec[0, 0] = 1.0
-    firstElTrace = _np.real(_tools.trace(_tools.ppvec_to_stdmx(dummyVec)))  # == sqrt(2)**nQubits
+    firstElTrace = _np.real(_np.trace(_tools.ppvec_to_stdmx(dummyVec)))  # == sqrt(2)**nQubits
     diff = 0
 
     # rhoVec must be positive semidefinite and trace = 1

pygsti/algorithms/core.py

@@ -31,8 +31,9 @@ from pygsti.modelmembers import instruments as _instrument
 from pygsti.modelmembers import states as _state
 from pygsti.circuits.circuitlist import CircuitList as _CircuitList
 from pygsti.baseobjs.resourceallocation import ResourceAllocation as _ResourceAllocation
-from pygsti.optimize.customlm import CustomLMOptimizer as _CustomLMOptimizer
-from pygsti.optimize.customlm import Optimizer as _Optimizer
+from pygsti.optimize.simplerlm import Optimizer as _Optimizer, SimplerLMOptimizer as _SimplerLMOptimizer
+from pygsti import forwardsims as _fwdsims
+from pygsti import layouts as _layouts
 
 _dummy_profiler = _DummyProfiler()
 
@@ -247,7 +248,10 @@ def run_lgst(dataset, prep_fiducials, effect_fiducials, target_model, op_labels=
                     circuit = rhostr
                 dsRow_fractions = dataset[circuit].fractions
                 # outcome labels should just be effect labels (no instruments!)
-                EVec[0, i] = dsRow_fractions[(effectLabel,)]
+                # when using a sparse data set format it might not be the case
+                # that all effect labels are present (only ones with non-zero counts are)
+                # so return 0 for the fraction in that case.
+                EVec[0, i] = dsRow_fractions.get((effectLabel,), 0)
             EVec_p = _np.dot(_np.dot(EVec, Vd), Pj)  # truncate Evec => Evec', shape (1,trunc)
             povm_effects.append((effectLabel, _np.transpose(EVec_p)))
         lgstModel.povms[povmLabel] = _povm.UnconstrainedPOVM(povm_effects, evotype='default')
@@ -262,7 +266,10 @@ def run_lgst(dataset, prep_fiducials, effect_fiducials, target_model, op_labels=
                 # try without prepLabel since it will be the default
                 circuit = estr
             dsRow_fractions = dataset[circuit].fractions
-            rhoVec[eoff:eoff + povmLen, 0] = [dsRow_fractions[(ol,)] for ol in target_model.povms[povmLbl]]
+            # when using a sparse data set format it might not be the case
+            # that all effect labels are present (only ones with non-zero counts are)
+            # so return 0 for the fraction in that case.
+            rhoVec[eoff:eoff + povmLen, 0] = [dsRow_fractions.get((ol,),0) for ol in target_model.povms[povmLbl]]
             eoff += povmLen
         rhoVec_p = _np.dot(Pjt, _np.dot(Ud, rhoVec))  # truncate rhoVec => rhoVec', shape (trunc, 1)
         rhoVec_p = _np.dot(invABMat_p, rhoVec_p)
@@ -394,7 +401,7 @@ def _construct_ab(prep_fiducials, effect_fiducials, model, dataset, op_label_ali
         for j, rhostr in enumerate(prep_fiducials):
             opLabelString = rhostr + estr  # LEXICOGRAPHICAL VS MATRIX ORDER
             dsStr = opLabelString.replace_layers_with_aliases(op_label_aliases)
-            expd_circuit_outcomes = opLabelString.expand_instruments_and_separate_povm(model)
+            expd_circuit_outcomes = model.expand_instruments_and_separate_povm(opLabelString)
             assert(len(expd_circuit_outcomes) == 1), "No instruments are allowed in LGST fiducials!"
             unique_key = next(iter(expd_circuit_outcomes.keys()))
             outcomes = expd_circuit_outcomes[unique_key]
@@ -423,7 +430,7 @@ def _construct_x_matrix(prep_fiducials, effect_fiducials, model, op_label_tuple,
         for j, rhostr in enumerate(prep_fiducials):
             opLabelString = rhostr + _circuits.Circuit(op_label_tuple, line_labels=rhostr.line_labels) + estr
             dsStr = opLabelString.replace_layers_with_aliases(op_label_aliases)
-            expd_circuit_outcomes = opLabelString.expand_instruments_and_separate_povm(model)
+            expd_circuit_outcomes = model.expand_instruments_and_separate_povm(opLabelString)
             dsRow_fractions = dataset[dsStr].fractions
             assert(len(expd_circuit_outcomes) == nVariants)
 
@@ -611,7 +618,7 @@ def run_gst_fit_simple(dataset, start_model, circuits, optimizer, objective_func
     model : Model
         the best-fit model.
     """
-    optimizer = optimizer if isinstance(optimizer, _Optimizer) else _CustomLMOptimizer.cast(optimizer)
+    optimizer = optimizer if isinstance(optimizer, _Optimizer) else _SimplerLMOptimizer.cast(optimizer)
     objective_function_builder = _objfns.ObjectiveFunctionBuilder.cast(objective_function_builder)
     array_types = optimizer.array_types + \
         objective_function_builder.compute_array_types(optimizer.called_objective_methods, start_model.sim)
@@ -658,7 +665,7 @@ def run_gst_fit(mdc_store, optimizer, objective_function_builder, verbosity=0):
     objfn_store : MDCObjectiveFunction
         the objective function and store containing the best-fit model evaluated at the best-fit point.
     """
-    optimizer = optimizer if isinstance(optimizer, _Optimizer) else _CustomLMOptimizer.cast(optimizer)
+    optimizer = optimizer if isinstance(optimizer, _Optimizer) else _SimplerLMOptimizer.cast(optimizer)
     comm = mdc_store.resource_alloc.comm
     profiler = mdc_store.resource_alloc.profiler
     printer = VerbosityPrinter.create_printer(verbosity, comm)
@@ -671,16 +678,10 @@ def run_gst_fit(mdc_store, optimizer, objective_function_builder, verbosity=0):
         if _np.linalg.norm(mdc_store.model.to_vector() - v_cmp) > 1e-6:
             raise ValueError("MPI ERROR: *different* MC2GST start models"
                              " given to different processors!")                   # pragma: no cover
-
-    #MEM from ..baseobjs.profiler import Profiler
-    #MEM debug_prof = Profiler(comm)
-    #MEM debug_prof.print_memory("run_gst_fit1", True)
-
+        
     if objective_function_builder is not None:
         objective_function_builder = _objfns.ObjectiveFunctionBuilder.cast(objective_function_builder)
-        #MEM debug_prof.print_memory("run_gst_fit2", True)
         objective = objective_function_builder.build_from_store(mdc_store, printer)  # (objective is *also* a store)
-        #MEM debug_prof.print_memory("run_gst_fit3", True)
     else:
         assert(isinstance(mdc_store, _objfns.ObjectiveFunction)), \
             "When `objective_function_builder` is None, `mdc_store` must be an objective fn!"
@@ -699,14 +700,8 @@ def run_gst_fit(mdc_store, optimizer, objective_function_builder, verbosity=0):
 
     printer.log("Completed in %.1fs" % (_time.time() - tStart), 1)
 
-    #if target_model is not None:
-    #  target_vec = target_model.to_vector()
-    #  targetErrVec = _objective_func(target_vec)
-    #  return minErrVec, soln_gs, targetErrVec
     profiler.add_time("do_mc2gst: total time", tStart)
-    #TODO: evTree.permute_computation_to_original(minErrVec) #Doesn't work b/c minErrVec is flattened
-    # but maybe best to just remove minErrVec from return value since this isn't very useful
-    # anyway?
+
     return opt_result, objective
 
 
@@ -847,7 +842,7 @@ def iterative_gst_generator(dataset, start_model, circuit_lists,
           (an "evaluated" model-dataset-circuits store).
     """
     resource_alloc = _ResourceAllocation.cast(resource_alloc)
-    optimizer = optimizer if isinstance(optimizer, _Optimizer) else _CustomLMOptimizer.cast(optimizer)
+    optimizer = optimizer if isinstance(optimizer, _Optimizer) else _SimplerLMOptimizer.cast(optimizer)
     comm = resource_alloc.comm
     profiler = resource_alloc.profiler
     printer = VerbosityPrinter.create_printer(verbosity, comm)
@@ -882,10 +877,30 @@ def iterative_gst_generator(dataset, start_model, circuit_lists,
     #The ModelDatasetCircuitsStore
     printer.log('Precomputing CircuitOutcomeProbabilityArray layouts for each iteration.', 2)
     precomp_layouts = []
+
+    #pre-compute a dictionary caching completed circuits for layout construction performance.
+    unique_circuits = list({ckt for circuit_list in circuit_lists for ckt in circuit_list})
+    if isinstance(mdl.sim, (_fwdsims.MatrixForwardSimulator, _fwdsims.MapForwardSimulator)):
+        precomp_layout_circuit_cache = mdl.sim.create_copa_layout_circuit_cache(unique_circuits, mdl, dataset=dataset)
+    else:
+        precomp_layout_circuit_cache = None
+
     for i, circuit_list in enumerate(circuit_lists):
         printer.log(f'Layout for iteration {i}', 2)
-        precomp_layouts.append(mdl.sim.create_layout(circuit_list, dataset, resource_alloc, array_types, verbosity= printer - 1))
-    
+        precomp_layouts.append(mdl.sim.create_layout(circuit_list, dataset, resource_alloc, array_types, verbosity= printer - 1,
+                                                    layout_creation_circuit_cache = precomp_layout_circuit_cache))
+        
+    #precompute a cache of possible outcome counts for each circuits to accelerate MDC store creation
+    if isinstance(mdl, _models.model.OpModel):
+        if precomp_layout_circuit_cache is not None: #then grab the split circuits from there.
+            expanded_circuit_outcome_list = mdl.bulk_expand_instruments_and_separate_povm(unique_circuits, 
+                                                                                          completed_circuits= precomp_layout_circuit_cache['completed_circuits'].values())
+        else:
+            expanded_circuit_outcome_list = mdl.bulk_expand_instruments_and_separate_povm(unique_circuits)        
+        outcome_count_by_circuit_cache = {ckt: len(outcome_tup) for ckt,outcome_tup in zip(unique_circuits, expanded_circuit_outcome_list)}
+    else:
+        outcome_count_by_circuit_cache = {ckt: mdl.compute_num_outcomes(ckt) for ckt in unique_circuits}
+
     with printer.progress_logging(1):
         for i in range(starting_index, len(circuit_lists)):
             circuitsToEstimate = circuit_lists[i]
@@ -902,7 +917,8 @@ def iterative_gst_generator(dataset, start_model, circuit_lists,
             mdl.basis = start_model.basis  # set basis in case of CPTP constraints (needed?)
             initial_mdc_store = _objfns.ModelDatasetCircuitsStore(mdl, dataset, circuitsToEstimate, resource_alloc,
                                                                   array_types=array_types, verbosity=printer - 1, 
-                                                                  precomp_layout = precomp_layouts[i])
+                                                                  precomp_layout = precomp_layouts[i],
+                                                                  outcome_count_by_circuit=outcome_count_by_circuit_cache)
             mdc_store = initial_mdc_store
 
             for j, obj_fn_builder in enumerate(iteration_objfn_builders):
@@ -1133,8 +1149,6 @@ def find_closest_unitary_opmx(operation_mx):
     # d = _np.sqrt(operation_mx.shape[0])
     # I = _np.identity(d)
 
-    #def getu_1q(basisVec):  # 1 qubit version
-    #    return _spl.expm( 1j * (basisVec[0]*_tools.sigmax + basisVec[1]*_tools.sigmay + basisVec[2]*_tools.sigmaz) )
     def _get_gate_mx_1q(basis_vec):  # 1 qubit version
         return _tools.single_qubit_gate(basis_vec[0],
                                         basis_vec[1],

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,

pygsti/algorithms/germselection.py

@@ -27,6 +27,7 @@ from pygsti.tools import mpitools as _mpit
 from pygsti.baseobjs.statespace import ExplicitStateSpace as _ExplicitStateSpace
 from pygsti.baseobjs.statespace import QuditSpace as _QuditSpace
 from pygsti.models import ExplicitOpModel as _ExplicitOpModel
+from pygsti.forwardsims import MatrixForwardSimulator as _MatrixForwardSimulator
 
 FLOATSIZE = 8  # in bytes: TODO: a better way
 
@@ -57,10 +58,8 @@ def find_germs(target_model, randomize=True, randomization_strength=1e-2,
 
     Parameters
     ----------
-    target_model : Model or list of Model
-        The model you are aiming to implement, or a list of models that are
-        copies of the model you are trying to implement (either with or
-        without random unitary perturbations applied to the models).
+    target_model : Model
+        The model you are aiming to implement.
 
     randomize : bool, optional
         Whether or not to add random unitary perturbations to the model(s)
@@ -188,8 +187,14 @@ def find_germs(target_model, randomize=True, randomization_strength=1e-2,
         A list containing the germs making up the germ set.
     """
     printer = _baseobjs.VerbosityPrinter.create_printer(verbosity, comm)
+    
+    if not isinstance(target_model.sim, _MatrixForwardSimulator):
+        target_model = target_model.copy()
+        target_model.sim = 'matrix'
+
     modelList = _setup_model_list(target_model, randomize,
                                   randomization_strength, num_gs_copies, seed)
+                                  
     gates = list(target_model.operations.keys())
     availableGermsList = []
     if candidate_germ_counts is None: candidate_germ_counts = {6: 'all upto'}
@@ -1351,6 +1356,10 @@ def test_germ_set_finitel(model, germs_to_test, length, weights=None,
         eigenvalues (from small to large) of the jacobian^T * jacobian
         matrix used to determine parameter amplification.
     """
+    if not isinstance(model.sim, _MatrixForwardSimulator):
+        model = model.copy()
+        model.sim = 'matrix'
+
     # Remove any SPAM vectors from model since we only want
     # to consider the set of *gate* parameters for amplification
     # and this makes sure our parameter counting is correct
@@ -3295,80 +3304,81 @@ def symmetric_low_rank_spectrum_update(update, orig_e, U, proj_U, force_rank_inc
     #return the new eigenvalues
     return new_evals, True
  
-#Note: This function won't work for our purposes because of the assumptions
-#about the rank of the update on the nullspace of the matrix we're updating,
-#but keeping this here commented for future reference.
-#Function for doing fast calculation of the updated inverse trace:
-#def riedel_style_inverse_trace(update, orig_e, U, proj_U, force_rank_increase=True):
-#    """
-#    input:
-#    
-#    update : ndarray
-#        symmetric low-rank update to perform.
-#        This is the first half the symmetric rank decomposition s.t.
-#        update@update.T= the full update matrix.
-#    
-#    orig_e : ndarray
-#        Spectrum of the original matrix. This is a 1-D array.
-#        
-#    proj_U : ndarray
-#        Projector onto the complement of the column space of the
-#        original matrix's eigenvectors.
-#        
-#    output:
-#    
-#    trace : float
-#        Value of the trace of the updated psuedoinverse matrix.
-#    
-#    updated_rank : int
-#        total rank of the updated matrix.
-#        
-#    rank_increase_flag : bool
-#        a flag that is returned to indicate is a candidate germ failed to amplify additional parameters. 
-#        This indicates things short circuited and so the scoring function should skip this germ.
-#    """
-#    
-#    #First we need to for the matrix P, whose column space
-#    #forms an orthonormal basis for the component of update
-#    #that is in the complement of U.
-#    
-#    proj_update= proj_U@update
-#    
-#    #Next take the RRQR decomposition of this matrix:
-#    q_update, r_update, _ = _sla.qr(proj_update, mode='economic', pivoting=True)
-#    
-#    #Construct P by taking the columns of q_update corresponding to non-zero values of r_A on the diagonal.
-#    nonzero_indices_update= _np.nonzero(_np.diag(r_update)>1e-10) #HARDCODED (threshold is hardcoded)
-#    
-#    #if the rank doesn't increase then we can't use the Riedel approach.
-#    #Abort early and return a flag to indicate the rank did not increase.
-#    if len(nonzero_indices_update[0])==0 and force_rank_increase:
-#        return None, None, False
-#    
-#    P= q_update[: , nonzero_indices_update[0]]
-#    
-#    updated_rank= len(orig_e)+ len(nonzero_indices_update[0])
-#    
-#    #Now form the matrix R_update which is given by P.T @ proj_update.
-#    R_update= P.T@proj_update
-#    
-#    #R_update gets concatenated with U.T@update to form
-#    #a block column matrixblock_column= np.concatenate([U.T@update, R_update], axis=0)    
-#    
-#    Uta= U.T@update
-#    
-#    try:
-#        RRRDinv= R_update@_np.linalg.inv(R_update.T@R_update) 
-#    except _np.linalg.LinAlgError as err:
-#        print('Numpy thinks this matrix is singular, condition number is: ', _np.linalg.cond(R_update.T@R_update))
-#        print((R_update.T@R_update).shape)
-#        raise err
-#    pinv_orig_e_mat= _np.diag(1/orig_e)
-#    
-#    trace= _np.sum(1/orig_e) + _np.trace( RRRDinv@(_np.eye(Uta.shape[1]) + Uta.T@pinv_orig_e_mat@Uta)@RRRDinv.T )
-#    
-#    return trace, updated_rank, True
+# Note: Th function below won't work for our purposes because of the assumptions
+# about the rank of the update on the nullspace of the matrix we're updating,
+# but keeping this here commented for future reference.
+'''
+def riedel_style_inverse_trace(update, orig_e, U, proj_U, force_rank_increase=True):
+    """
+    input:
+    
+    update : ndarray
+        symmetric low-rank update to perform.
+        This is the first half the symmetric rank decomposition s.t.
+        update@update.T= the full update matrix.
+    
+    orig_e : ndarray
+        Spectrum of the original matrix. This is a 1-D array.
+        
+    proj_U : ndarray
+        Projector onto the complement of the column space of the
+        original matrix's eigenvectors.
+        
+    output:
+    
+    trace : float
+        Value of the trace of the updated psuedoinverse matrix.
+    
+    updated_rank : int
+        total rank of the updated matrix.
+        
+    rank_increase_flag : bool
+        a flag that is returned to indicate is a candidate germ failed to amplify additional parameters. 
+        This indicates things short circuited and so the scoring function should skip this germ.
+    """
     
+    #First we need to for the matrix P, whose column space
+    #forms an orthonormal basis for the component of update
+    #that is in the complement of U.
+    
+    proj_update= proj_U@update
+    
+    #Next take the RRQR decomposition of this matrix:
+    q_update, r_update, _ = _sla.qr(proj_update, mode='economic', pivoting=True)
+    
+    #Construct P by taking the columns of q_update corresponding to non-zero values of r_A on the diagonal.
+    nonzero_indices_update= _np.nonzero(_np.diag(r_update)>1e-10) #HARDCODED (threshold is hardcoded)
+    
+    #if the rank doesn't increase then we can't use the Riedel approach.
+    #Abort early and return a flag to indicate the rank did not increase.
+    if len(nonzero_indices_update[0])==0 and force_rank_increase:
+        return None, None, False
+    
+    P= q_update[: , nonzero_indices_update[0]]
+    
+    updated_rank= len(orig_e)+ len(nonzero_indices_update[0])
+    
+    #Now form the matrix R_update which is given by P.T @ proj_update.
+    R_update= P.T@proj_update
+    
+    #R_update gets concatenated with U.T@update to form
+    #a block column matrixblock_column= np.concatenate([U.T@update, R_update], axis=0)    
+    
+    Uta= U.T@update
+    
+    try:
+        RRRDinv= R_update@_np.linalg.inv(R_update.T@R_update) 
+    except _np.linalg.LinAlgError as err:
+        print('Numpy thinks this matrix is singular, condition number is: ', _np.linalg.cond(R_update.T@R_update))
+        print((R_update.T@R_update).shape)
+        raise err
+    pinv_orig_e_mat= _np.diag(1/orig_e)
+    
+    trace= _np.sum(1/orig_e) + _np.trace( RRRDinv@(_np.eye(Uta.shape[1]) + Uta.T@pinv_orig_e_mat@Uta)@RRRDinv.T )
+    
+    return trace, updated_rank, True
+'''
+
 def minamide_style_inverse_trace(update, orig_e, U, proj_U, force_rank_increase=False):
     """
     This function performs a low-rank update to the components of