pyGSTi 0.9.12__cp39-cp39-win32.whl → 0.9.13__cp39-cp39-win32.whl

pygsti/tools/nameddict.py

@@ -88,7 +88,7 @@ class NamedDict(dict, _NicelySerializable):
             #TODO: serialize via _to_memoized_dict once we have a base class
             if x is None or isinstance(x, (float, int, str)):
                 return x
-            elif isinstance(x, _np.int64):
+            elif isinstance(x, (_np.int64, _np.int32)):
                 return int(x)
             elif isinstance(x, _NicelySerializable):
                 return x.to_nice_serialization()

pygsti/tools/optools.py

@@ -34,28 +34,17 @@ IMAG_TOL = 1e-7  # tolerance for imaginary part being considered zero
 def _flat_mut_blks(i, j, block_dims):
     # like _mut(i,j,dim).flatten() but works with basis *blocks*
     N = sum(block_dims)
-    mx = _np.zeros((N, N), 'd'); mx[i, j] = 1.0
+    mx = _np.zeros((N, N), 'd')
+    mx[i, j] = 1.0
     ret = _np.zeros(sum([d**2 for d in block_dims]), 'd')
     i = 0; off = 0
     for d in block_dims:
-        ret[i:i + d**2] = mx[off:off + d, off:off + d].flatten()
-        i += d**2; off += d
+        ret[i:i + d**2] = mx[off:off + d, off:off + d].ravel()
+        i += d**2
+        off += d
     return ret
 
 
-def _hack_sqrtm(a):
-    sqrt, _ = _spl.sqrtm(a, disp=False)  # Travis found this scipy function
-    # to be incorrect in certain cases (we need a workaround)
-    if _np.any(_np.isnan(sqrt)):  # this is sometimes a good fallback when sqrtm doesn't work.
-        ev, U = _np.linalg.eig(a)
-        sqrt = _np.dot(U, _np.dot(_np.diag(_np.sqrt(ev)), _np.linalg.inv(U)))
-    # Scipy 1.10 fix for PR 16294 (which doubles precision of complex to complex)
-    if _np.iscomplexobj(a):
-        sqrt = sqrt.astype(a.dtype, copy=False)
-
-    return sqrt
-
-
 def fidelity(a, b):
     """
     Returns the quantum state fidelity between density matrices.
@@ -81,41 +70,120 @@ def fidelity(a, b):
     float
         The resulting fidelity.
     """
-    evals, U = _np.linalg.eig(a)
-    if len([ev for ev in evals if abs(ev) > 1e-8]) == 1:
-        # special case when a is rank 1, a = vec * vec^T and sqrt(a) = a
-        ivec = _np.argmax(evals)
-        vec = U[:, ivec:(ivec + 1)]
-        F = evals[ivec].real * _np.dot(_np.conjugate(_np.transpose(vec)), _np.dot(b, vec)).real  # vec^T * b * vec
-        return float(F[0, 0])
-
-    evals, U = _np.linalg.eig(b)
-    if len([ev for ev in evals if abs(ev) > 1e-8]) == 1:
-        # special case when b is rank 1 (recally fidelity is sym in args)
-        ivec = _np.argmax(evals)
-        vec = U[:, ivec:(ivec + 1)]
-        F = evals[ivec].real * _np.dot(_np.conjugate(_np.transpose(vec)), _np.dot(a, vec)).real  # vec^T * a * vec
-        return float(F[0, 0])
-
-    #if _np.array_equal(a, b): return 1.0  # HACK - some cases when a and b are perfecty equal sqrtm(a) fails...
-    sqrtA = _hack_sqrtm(a)  # _spl.sqrtm(a)
-    # test the scipy sqrtm function - sometimes fails when rank defficient
-    #assert(_np.linalg.norm(_np.dot(sqrtA, sqrtA) - a) < 1e-8)
-    if _np.linalg.norm(_np.dot(sqrtA, sqrtA) - a) > 1e-8:
-        evals = _np.linalg.eigvals(a)
-        _warnings.warn(("sqrtm(a) failure when computing fidelity - beware result. "
-                        "Maybe due to rank defficiency - eigenvalues of a are: %s") % evals)
-    F = (_mt.trace(_hack_sqrtm(_np.dot(sqrtA, _np.dot(b, sqrtA)))).real)**2  # Tr( sqrt{ sqrt(a) * b * sqrt(a) } )^2
-    return float(F)
+    __SCALAR_TOL__ = _np.finfo(a.dtype).eps ** 0.75
+    # ^ use for checks that have no dimensional dependence; about 1e-12 for double precision.
+    __VECTOR_TOL__ = (a.shape[0] ** 0.5) * __SCALAR_TOL__
+    # ^ use for checks that do have dimensional dependence (will naturally increase for larger matrices)
+
+    def assert_hermitian(mat):
+        hermiticity_error = _np.abs(mat - mat.T.conj())
+        if _np.any(hermiticity_error > __SCALAR_TOL__):
+            message = f"""
+                Input matrix 'mat' is not Hermitian, up to tolerance {__SCALAR_TOL__}.
+                The absolute values of entries in (mat - mat^H) are \n{hermiticity_error}. 
+            """
+            raise ValueError(message)
+    
+    assert_hermitian(a)
+    assert_hermitian(b)
+
+    def check_rank_one_density(mat):
+        """
+        mat is Hermitian of order n. This function uses an O(n^2) time randomized algorithm to
+        test if mat is a PSD matrix of rank 0 or 1. It returns a tuple (r, vec), where
+
+            If r == 0, then vec is the zero vector. Either mat's numerical rank is zero
+            OR the projection of mat onto the set of PSD matrices is zero.
+
+            If r == 1, then mat is a PSD matrix of numerical rank one, and vec is mat's
+            unique nontrivial eigenvector.
+
+            If r == 2, then vec is None and our best guess is that mat's (numerical) rank
+            is at least two. In exact arithmetic, this "guess" is correct with probability
+            one. Additional computations will be needed to determine if mat is PSD.
+
+        Conceptually, this function just takes a single step of the power iteration method
+        for estimating mat's largest eigenvalue (with size measured in absolute value).
+        See https://en.wikipedia.org/wiki/Power_iteration for more information.
+        """
+        n = mat.shape[0]
+
+        if _np.linalg.norm(mat) < __VECTOR_TOL__:
+            # We prefer to return the zero vector instead of None to simplify how we handle
+            # this function's output.
+            return 0, _np.zeros(n, dtype=complex)
+
+        _np.random.seed(0)
+        test_vec = _np.random.randn(n) + 1j * _np.random.randn(n)
+        test_vec /= _np.linalg.norm(test_vec)
+
+        candidate_v = mat @ test_vec
+        candidate_v /= _np.linalg.norm(candidate_v)
+        alpha = _np.real(candidate_v.conj() @ mat @ candidate_v)
+        reconstruction = alpha * _np.outer(candidate_v, candidate_v.conj())
+
+        if _np.linalg.norm(mat - reconstruction) > __VECTOR_TOL__:
+            # We can't certify that mat is rank-1.
+            return 2, None
+        
+        if alpha <= 0.0:
+            # Ordinarily we'd project out the negative eigenvalues and proceed with the
+            # PSD part of the matrix, but at this point we know that the PSD part is zero.
+            return 0, _np.zeros(n)
+        
+        if abs(alpha - 1) > __SCALAR_TOL__:
+            message = f"The input matrix is not trace-1 up to tolerance {__SCALAR_TOL__}. Beware result!"
+            _warnings.warn(message)
+            candidate_v *= _np.sqrt(alpha)
+
+        return 1, candidate_v
+  
+    r, vec = check_rank_one_density(a)
+    if r <= 1:
+        # special case when a is rank 1, a = vec * vec^T.
+        f = (vec.T.conj() @ b @ vec).real  # vec^T * b * vec
+        return f
+
+    r, vec = check_rank_one_density(b)
+    if r <= 1:
+        # special case when b is rank 1 (recall fidelity is sym in args)
+        f = (vec.T.conj() @ a @ vec).real  # vec^T * a * vec
+        return f
+    
+    # Neither a nor b are rank-1. We need to actually evaluate the matrix square root of
+    # one of them. We do this with an eigendecomposition, since this lets us check for 
+    # negative eigenvalues and raise a warning if needed.
+
+    def psd_square_root(mat):
+        evals, U = _np.linalg.eigh(mat)
+        if _np.min(evals) < -__SCALAR_TOL__:
+            message = f"""
+            Input matrix is not PSD up to tolerance {__SCALAR_TOL__}.
+            We'll project out the bad eigenspaces to only work with the PSD part.
+            """
+            _warnings.warn(message)
+        evals[evals < 0] = 0.0
+        tr = _np.sum(evals)
+        if abs(tr - 1) > __VECTOR_TOL__:
+            message = f"""
+            The PSD part of the input matrix is not trace-1 up to tolerance {__VECTOR_TOL__}.
+            Beware result!
+            """
+            _warnings.warn(message)
+        sqrt_mat = U @ (_np.sqrt(evals).reshape((-1, 1)) * U.T.conj())
+        return sqrt_mat
+    
+    sqrt_a = psd_square_root(a)
+    tr_arg = psd_square_root(sqrt_a @ b @ sqrt_a)
+    f = _np.trace(tr_arg).real ** 2  # Tr( sqrt{ sqrt(a) * b * sqrt(a) } )^2
+    return f
 
 
 def frobeniusdist(a, b):
     """
-    Returns the frobenius distance between gate or density matrices.
-
-    This is given by :
+    Returns the frobenius distance between arrays: ||a - b||_Fro.
 
-      `sqrt( sum( (a_ij-b_ij)^2 ) )`
+    This could be inlined, but we're keeping it for API consistency with other distance functions.
 
     Parameters
     ----------
@@ -130,16 +198,14 @@ def frobeniusdist(a, b):
     float
         The resulting frobenius distance.
     """
-    return _mt.frobeniusnorm(a - b)
+    return _np.linalg.norm(a - b)
 
 
 def frobeniusdist_squared(a, b):
     """
-    Returns the square of the frobenius distance between gate or density matrices.
+    Returns the square of the frobenius distance between arrays: (||a - b||_Fro)^2.
 
-    This is given by :
-
-      `sum( (A_ij-B_ij)^2 )`
+    This could be inlined, but we're keeping it for API consistency with other distance functions.
 
     Parameters
     ----------
@@ -154,27 +220,7 @@ def frobeniusdist_squared(a, b):
     float
         The resulting frobenius distance.
     """
-    return _mt.frobeniusnorm_squared(a - b)
-
-
-def residuals(a, b):
-    """
-    Calculate residuals between the elements of two matrices
-
-    Parameters
-    ----------
-    a : numpy array
-        First matrix.
-
-    b : numpy array
-        Second matrix.
-
-    Returns
-    -------
-    np.array
-        residuals
-    """
-    return (a - b).flatten()
+    return frobeniusdist(a, b)**2
 
 
 def tracenorm(a):
@@ -402,11 +448,13 @@ def entanglement_fidelity(a, b, mx_basis='pp', is_tp=None, is_unitary=None):
         
     Parameters
     ----------
-    a : numpy array
-        First matrix.
+    a : array or gate
+        The gate to compute the entanglement fidelity to b of. E.g., an 
+        imperfect implementation of b.
 
-    b : numpy array
-        Second matrix.
+    b : array or gate
+        The gate to compute the entanglement fidelity to a of. E.g., the 
+        target gate corresponding to a.
 
     mx_basis : {'std', 'gm', 'pp', 'qt'} or Basis object
         The basis of the matrices.  Allowed values are Matrix-unit (std),
@@ -430,6 +478,15 @@ def entanglement_fidelity(a, b, mx_basis='pp', is_tp=None, is_unitary=None):
     -------
     float
     """
+    from pygsti.modelmembers.operations.linearop import LinearOperator as _LinearOperator
+
+    # Attempt to cast to dense array. If this is already an array, the AttributeError
+    # will be suppressed.
+    if isinstance(a, _LinearOperator):
+        a = a.to_dense()
+    if isinstance(b, _LinearOperator):
+        b = b.to_dense()
+
     d2 = a.shape[0]
     
     #if the tp flag isn't set we'll calculate whether it is true here
@@ -504,6 +561,12 @@ def average_gate_fidelity(a, b, mx_basis='pp', is_tp=None, is_unitary=None):
     AGI : float
         The AGI of a to b.
     """
+    from pygsti.modelmembers.operations.linearop import LinearOperator as _LinearOperator
+    
+    # Cast to dense to ensure we can extract the shape.
+    if isinstance(a, _LinearOperator):
+        a = a.to_dense()
+
     d = int(round(_np.sqrt(a.shape[0])))
     PF = entanglement_fidelity(a, b, mx_basis, is_tp, is_unitary)
     AGF = (d * PF + 1) / (1 + d)
@@ -710,6 +773,12 @@ def unitarity(a, mx_basis="gm"):
     -------
     float
     """
+    from pygsti.modelmembers.operations.linearop import LinearOperator as _LinearOperator
+
+    # Cast to dense to ensure we can extract the shape.
+    if isinstance(a, _LinearOperator):
+        a = a.to_dense()
+        
     d = int(round(_np.sqrt(a.shape[0])))
     basisMxs = _bt.basis_matrices(mx_basis, a.shape[0])
 
@@ -719,10 +788,7 @@ def unitarity(a, mx_basis="gm"):
         B = _bt.change_basis(a, mx_basis, "gm")  # everything should be able to be put in the "gm" basis
 
     unital = B[1:d**2, 1:d**2]
-    #old version
-    #u = _np.trace(_np.dot(_np.conj(_np.transpose(unital)), unital)) / (d**2 - 1)
-    #new version
-    u= _np.einsum('ij,ji->', unital.conjugate().T, unital ) / (d**2 - 1)
+    u = _np.linalg.norm(unital)**2 / (d**2 - 1)
     return u
 
 
@@ -755,7 +821,7 @@ def fidelity_upper_bound(operation_mx):
     # # gives same result:
     # closestUnitaryJmx = _np.dot(choi_evecs, _np.dot( _np.diag(new_evals), _np.linalg.inv(choi_evecs) ) )
     closestJmx = _np.kron(closestVec, _np.transpose(_np.conjugate(closestVec)))  # closest rank-1 Jmx
-    closestJmx /= _mt.trace(closestJmx)  # normalize so trace of Jmx == 1.0
+    closestJmx /= _np.trace(closestJmx)  # normalize so trace of Jmx == 1.0
 
     maxF = fidelity(choi, closestJmx)
 
@@ -768,7 +834,7 @@ def fidelity_upper_bound(operation_mx):
         #    print "DEBUG choi_evals = ",choi_evals, " iMax = ",iMax
         #    #print "DEBUG: J = \n", closestUnitaryJmx
         #    print "DEBUG: eigvals(J) = ", _np.linalg.eigvals(closestJmx)
-        #    print "DEBUG: trace(J) = ", _mt.trace(closestJmx)
+        #    print "DEBUG: trace(J) = ", _np.trace(closestJmx)
         #    print "DEBUG: maxF = %f,  maxF_direct = %f" % (maxF, maxF_direct)
         #    raise ValueError("ERROR: maxF - maxF_direct = %f" % (maxF -maxF_direct))
         assert(abs(maxF - maxF_direct) < 1e-6)
@@ -1097,8 +1163,8 @@ def state_to_dmvec(psi):
         The vectorized density matrix.
     """
     psi = psi.reshape((psi.size, 1))  # convert to (N,1) shape if necessary
-    dm = _np.dot(psi, _np.conjugate(psi.T))
-    return dm.flatten()
+    dm = psi @ psi.conj().T
+    return dm.ravel()
 
 
 def dmvec_to_state(dmvec, tol=1e-6):
@@ -1577,7 +1643,7 @@ def extract_elementary_errorgen_coefficients(errorgen, elementary_errorgen_label
                                          errorgen_basis.create_simple_equivalent('std'))
     else:
         errorgen_std = _bt.change_basis(errorgen, errorgen_basis, "std")
-    flat_errorgen_std = errorgen_std.toarray().flatten() if _sps.issparse(errorgen_std) else errorgen_std.flatten()
+    flat_errorgen_std = errorgen_std.toarray().ravel() if _sps.issparse(errorgen_std) else errorgen_std.ravel()
 
     d2 = errorgen_std.shape[0]
     d = int(_np.sqrt(d2))
@@ -1593,7 +1659,7 @@ def extract_elementary_errorgen_coefficients(errorgen, elementary_errorgen_label
         bel_lbls = key.basis_element_labels
         bmx0 = elementary_errorgen_basis[bel_lbls[0]]
         bmx1 = elementary_errorgen_basis[bel_lbls[1]] if (len(bel_lbls) > 1) else None
-        flat_projector = _lt.create_elementary_errorgen_dual(key.errorgen_type, bmx0, bmx1, sparse=False).flatten()
+        flat_projector = _lt.create_elementary_errorgen_dual(key.errorgen_type, bmx0, bmx1, sparse=False).ravel()
         projections[key] = _np.real_if_close(_np.vdot(flat_projector, flat_errorgen_std), tol=1000)
         if return_projected_errorgen:
             space_projector[:, i] = flat_projector
@@ -1673,7 +1739,7 @@ def project_errorgen(errorgen, elementary_errorgen_type, elementary_errorgen_bas
                                          errorgen_basis.create_simple_equivalent('std'))
     else:
         errorgen_std = _bt.change_basis(errorgen, errorgen_basis, "std")
-    flat_errorgen_std = errorgen_std.toarray().flatten() if _sps.issparse(errorgen_std) else errorgen_std.flatten()
+    flat_errorgen_std = errorgen_std.toarray().ravel() if _sps.issparse(errorgen_std) else errorgen_std.ravel()
 
     d2 = errorgen_std.shape[0]
     d = int(_np.sqrt(d2))
@@ -1687,7 +1753,7 @@ def project_errorgen(errorgen, elementary_errorgen_type, elementary_errorgen_bas
         space_projector = _np.empty((d2 * d2, len(projectors)), complex)
 
     for i, (lbl, projector) in enumerate(projectors.items()):
-        flat_projector = projector.flatten()
+        flat_projector = projector.ravel()
         proj = _np.real_if_close(_np.vdot(flat_projector, flat_errorgen_std), tol=1000)
         if return_projected_errorgen:
             space_projector[:, i] = flat_projector

pygsti/tools/pdftools.py

@@ -71,28 +71,3 @@ def classical_fidelity(p, q):
     #    sqrt_fidelity += _np.sqrt(x * y)
 
     return _np.sum([_np.sqrt(x * q.get(event, 0.)) for (event, x) in p.items()]) ** 2
-
-    #return root_fidelity ** 2
-
-
-# def Hoyer_sparsity_measure(p, n):
-#     """
-#     Computes a measure of the sparsity ("spikyness") of a probability distribution (or a
-#     general real vector).
-
-#     Parameters
-#     ----------
-#     p : dict
-#         The distribution
-
-#     n : the number of possible events (zero probability events do not need to be included in `p`)
-
-#     Returns
-#     -------
-#     float
-#     """
-#     plist = _np.array(list(p.values()))
-#     twonorm = _np.sqrt(_np.sum(plist**2))
-#     onenorm = _np.sum(_np.abs(plist))
-#     max_onenorm_over_twonorm = _np.sqrt(n)
-#     return (max_onenorm_over_twonorm - onenorm/twonorm) / (max_onenorm_over_twonorm - 1)