pyGSTi 0.9.12__cp310-cp310-win_amd64.whl → 0.9.13__cp310-cp310-win_amd64.whl

pygsti/tools/fastcalc.pyx

@@ -14,6 +14,7 @@
 
 import numpy as np
 from libc.stdlib cimport malloc, free
+from functools import lru_cache
 cimport numpy as np
 cimport cython
 
@@ -50,7 +51,7 @@ def embedded_fast_acton_sparse(embedded_gate_acton_fn,
     cdef np.ndarray[double, ndim=1, mode="c"] slc1 = np.empty(nActionIndices, dtype='d')
     cdef np.ndarray[double, ndim=1, mode="c"] slc2 = np.empty(nActionIndices, dtype='d')
 
-    # nActionIndices = np.product(numBasisEls_action)
+    # nActionIndices = np.prod(numBasisEls_action)
     #for i in range(nAction):
     #    nActionIndices *= numBasisEls_action[i]
 
@@ -274,7 +275,7 @@ def embedded_fast_acton_sparse_complex(embedded_gate_acton_fn,
     cdef np.ndarray[np.complex128_t, ndim=1, mode="c"] slc1 = np.empty(nActionIndices, dtype=np.complex128)
     cdef np.ndarray[np.complex128_t, ndim=1, mode="c"] slc2 = np.empty(nActionIndices, dtype=np.complex128)
 
-    # nActionIndices = np.product(numBasisEls_action)
+    # nActionIndices = np.prod(numBasisEls_action)
     #for i in range(nAction):
     #    nActionIndices *= numBasisEls_action[i]
 
@@ -570,67 +571,6 @@ def fast_kron(np.ndarray[double, ndim=1, mode="c"] outvec not None,
             outvec[endoff+i] *= mult
         sz *= fastArraySizes[k]
 
-    #assert(sz == N)
-
-
-
-#An attempt at a faster matrix prod specific to 2D matrices -- much SLOWER than numpy!!
-#@cython.cdivision(True) # turn off divide-by-zero checking
-#@cython.boundscheck(False) # turn off bounds-checking for entire function
-#@cython.wraparound(False)  # turn off negative index wrapping for entire function
-#def fast_dot2(np.ndarray[double, ndim=2] out,
-#              np.ndarray[double, ndim=2] a, np.ndarray[double, ndim=2] b):
-#    cdef double* out_ptr = <double*>out.data
-#    cdef double* a_ptr = <double*>a.data
-#    cdef double* b_ptr = <double*>b.data
-#    cdef double* arow
-#    cdef double* bcol
-#    cdef double* outrow
-#    cdef double tot
-#    cdef INT m = a.shape[0]
-#    cdef INT n = b.shape[1]
-#    cdef INT l = a.shape[1]
-#    cdef INT astride = a.strides[0] // a.itemsize
-#    cdef INT bstride = b.strides[0] // b.itemsize
-#    cdef INT outstride = out.strides[0] // out.itemsize
-#    cdef INT ainc = a.strides[1] // a.itemsize
-#    cdef INT binc = b.strides[1] // b.itemsize
-#    cdef INT outinc = out.strides[1] // out.itemsize
-#    cdef INT i_times_astride
-#    cdef INT i_times_outstride
-#    cdef INT j_times_binc
-#    cdef INT j_times_outinc
-#    cdef INT k_times_bstride
-#    cdef INT k_times_ainc
-#    cdef INT i
-#    cdef INT j
-#    cdef INT k
-#
-#    # out_ij = sum_k a_ik * b_kl
-#
-#    i_times_astride = 0
-#    i_times_outstride = 0
-#    for i in range(m):
-#        arow = &a_ptr[i_times_astride]
-#        outrow = &out_ptr[i_times_outstride]
-#        j_times_binc = 0
-#        j_times_outinc = 0
-#        for j in range(n):
-#            bcol = &b_ptr[j_times_binc]
-#            k_times_bstride = 0
-#            k_times_ainc = 0
-#            tot = 0.0
-#            for k in range(l):
-#                tot = tot + arow[k_times_ainc] * bcol[k_times_bstride]
-#                k_times_bstride = k_times_bstride + bstride
-#                k_times_ainc = k_times_ainc + ainc
-#            outrow[j_times_outinc] = tot
-#            j_times_binc = j_times_binc + binc
-#            j_times_outinc = j_times_outinc + outinc
-#        i_times_astride = i_times_astride + astride
-#        i_times_outstride = i_times_outstride + outstride
-
-
 @cython.boundscheck(False) # turn off bounds-checking for entire function
 @cython.wraparound(False)  # turn off negative index wrapping for entire function
 def fast_kron_complex(np.ndarray[np.complex128_t, ndim=1, mode="c"] outvec not None,
@@ -680,21 +620,6 @@ def fast_kron_complex(np.ndarray[np.complex128_t, ndim=1, mode="c"] outvec not N
     #assert(sz == N)
 
 
-#Manually inline to avoid overhead of argument passing
-#@cython.boundscheck(False) # turn off bounds-checking for entire function
-#@cython.wraparound(False)  # turn off negative index wrapping for entire function
-#cdef vec_inf_norm(np.ndarray[double, ndim=1] v):
-#    cdef INT i
-#    cdef INT N = v.shape[0]
-#    cdef double mx = 0.0
-#    cdef double a
-#    for i in range(N):
-#        a = abs(v[i])
-#        if a > mx: mx = a
-#    return mx
-
-
-
 @cython.cdivision(True) # turn off divide-by-zero checking
 @cython.boundscheck(False) # turn off bounds-checking for entire function
 @cython.wraparound(False)  # turn off negative index wrapping for entire function
@@ -716,9 +641,6 @@ def custom_expm_multiply_simple_core(np.ndarray[double, ndim=1, mode="c"] Adata,
                                        &F[0], &scratch[0])
     return F
 
-
-
-
 @cython.cdivision(True) # turn off divide-by-zero checking
 cdef custom_expm_multiply_simple_core_c(double* Adata, INT* Aindptr,
                                         INT* Aindices, double* B,
@@ -1305,6 +1227,38 @@ def fast_compose_cliffords(np.ndarray[np.int64_t, ndim=2] s1, np.ndarray[np.int6
     return s, p
 
 
+#Faster generation of upper triangular indices specialized to first
+#superdiagonal and up.
+@cython.boundscheck(False)  # Deactivate bounds checking
+@cython.wraparound(False)   # Deactivate negative indexing.
+@cython.cdivision(True)
+@lru_cache(maxsize=16)
+def fast_triu_indices(int n):
+    if n < 1:
+        raise ValueError('n must be greater than 0')
+        
+    cdef int size = (n**2-n)/2
+    cdef int curr_idx = 0
+    cdef int j, i
+    
+    cdef np.ndarray[np.int64_t, ndim=1, mode="c"] row_indices_np = np.empty(size, dtype=np.int64)
+    cdef np.ndarray[np.int64_t, ndim=1, mode="c"] col_indices_np = np.empty(size, dtype=np.int64)
+    
+    cdef np.int64_t[::1] row_indices = row_indices_np
+    cdef np.int64_t[::1] col_indices = col_indices_np
+
+    for j in range(n-1):
+        for i in range(n-j-1, 0, -1):
+            row_indices[curr_idx] = j
+            curr_idx += 1
+
+    curr_idx = 0
+    for j in range(1, n):
+        for i in range(j, n):
+            col_indices[curr_idx] = i
+            curr_idx += 1
+
+    return row_indices_np, col_indices_np
 
 
 

pygsti/tools/internalgates.py

@@ -16,6 +16,7 @@ import scipy.linalg as _spl
 from pygsti.tools import optools as _ot
 from pygsti.tools import symplectic as _symp
 from pygsti.baseobjs.unitarygatefunction import UnitaryGateFunction as _UnitaryGateFunction
+from pygsti.tools.gatetools import sigmax, sigmay, sigmaz, sigmaxz
 
 
 class Gzr(_UnitaryGateFunction):
@@ -192,14 +193,18 @@ def standard_gatename_unitaries():
       * 'Gxmpi2','Gympi2','Gzmpi2' : 1Q -pi/2 rotations around X, Y and Z.
       * 'Gh' : Hadamard.
       * 'Gp', 'Gpdag' : phase and inverse phase (an alternative notation/name for Gzpi and Gzmpi2).
-      * 'Gci' where `i = 0, 1, ..., 23` : the 24 1-qubit Cliffor gates (all the gates above are included as one of these).
-      * 'Gcphase','Gcnot','Gswap' : standard 2Q gates.
-
+      * 'Gci' where `i = 0, 1, ..., 23` : the 24 1-qubit Clifford gates (all the gates above are included as one of these).
+      * 'Gcphase','Gcnot','Gswap', 'Giswap' : standard 2Q gates.
+      * 'Gsqrtiswap' : square-root of ISWAP gate, used in some superconducting qubit platforms.
+      * 'Gxx', 'Gzz' : MS-style parity gates
+      * 'Gcres', 'Gecres' : Cross-resonance and echoed cross-resonance gates. Native gate operations common on transmon systems (including IBM).
+      
     * Non-Clifford gates:
 
       * 'Gt', 'Gtdag' : the T and inverse T gates (T is a Z rotation by pi/4).
       * 'Gzr' : a parameterized gate that is a Z rotation by an angle, where when the angle = pi then it equals Z.
-
+      * 'Gn' : N gate, pi/2 rotation about the (np.sqrt(3)/2, 0, -1/2) axis of the Bloch sphere, native gate in some spin qubit systems.
+      
     Mostly, pyGSTi does not assume that a gate with one of these names is indeed
     the unitary specified here. Instead, these names are intended as short-hand
     for defining ProcessorSpecs and n-qubit models. Moreover, when these names
@@ -212,10 +217,6 @@ def standard_gatename_unitaries():
     """
     std_unitaries = {}
 
-    sigmax = _np.array([[0, 1], [1, 0]])
-    sigmay = _np.array([[0, -1.0j], [1.0j, 0]])
-    sigmaz = _np.array([[1, 0], [0, -1]])
-
     def u_op(exp):
         return _np.array(_spl.expm(-1j * exp / 2), complex)
 
@@ -233,6 +234,11 @@ def standard_gatename_unitaries():
     std_unitaries['Gympi2'] = u_op(-1 * _np.pi / 2 * sigmay)
     std_unitaries['Gzmpi2'] = u_op(-1 * _np.pi / 2 * sigmaz)
 
+    std_unitaries['Gxpi4'] = u_op(_np.pi / 4 * sigmax)
+    std_unitaries['Gypi4'] = u_op(_np.pi / 4 * sigmay)
+    std_unitaries['Gzpi4'] = u_op(_np.pi / 4 * sigmaz)
+    
+
     H = (1 / _np.sqrt(2)) * _np.array([[1., 1.], [1., -1.]], complex)
     P = _np.array([[1., 0.], [0., 1j]], complex)
     Pdag = _np.array([[1., 0.], [0., -1j]], complex)
@@ -245,6 +251,11 @@ def standard_gatename_unitaries():
     #std_unitaries['Ghph'] = _np.dot(H,_np.dot(P,H))
     std_unitaries['Gt'] = _np.array([[1., 0.], [0., _np.exp(1j * _np.pi / 4)]], complex)
     std_unitaries['Gtdag'] = _np.array([[1., 0.], [0., _np.exp(-1j * _np.pi / 4)]], complex)
+    
+    #N gate, pi/2 rotation about the (np.sqrt(3)/2, 0, -1/2) axis of the Bloch sphere
+    #native gate in some spin qubit systems.
+    std_unitaries['Gn'] = _spl.expm(-1j*(_np.pi/4)*((_np.sqrt(3)/2)*sigmax - (.5)*sigmaz))
+
     # The 1-qubit Clifford group. The labelling is the same as in the the 1-qubit Clifford group generated
     # in pygsti.extras.rb.group, and also in the internal standard unitary (but with 'Gci' -> 'Ci')
     std_unitaries['Gc0'] = _np.array([[1, 0], [0, 1]], complex)  # This is Gi
@@ -273,6 +284,7 @@ def standard_gatename_unitaries():
     std_unitaries['Gc21'] = _np.array([[1, -1], [1, 1]], complex) / _np.sqrt(2)  # This is Gypi2 (up to phase)
     std_unitaries['Gc22'] = _np.array([[0.5 + 0.5j, 0.5 - 0.5j], [-0.5 + 0.5j, -0.5 - 0.5j]], complex)
     std_unitaries['Gc23'] = _np.array([[1, 0], [0, -1j]], complex)  # This is Gzmpi2 / Gpdag (up to phase)
+    
     # Two-qubit gates
     std_unitaries['Gcphase'] = _np.array([[1., 0., 0., 0.], [0., 1., 0., 0.], [
                                          0., 0., 1., 0.], [0., 0., 0., -1.]], complex)
@@ -285,10 +297,21 @@ def standard_gatename_unitaries():
     std_unitaries['Gswap'] = _np.array([[1., 0., 0., 0.], [0., 0., 1., 0.],
                                         [0., 1., 0., 0.], [0., 0., 0., 1.]], complex)
 
+    std_unitaries['Giswap'] = _np.array([[1., 0., 0., 0.], [0., 0., 1j, 0.],
+                                        [0., 1j, 0., 0.], [0., 0., 0., 1.]], complex)
+    
+    std_unitaries['Gsqrtiswap'] = _np.array([[1., 0., 0., 0.], [0., 1/_np.sqrt(2), 1j/_np.sqrt(2), 0.],
+                                        [0., 1j/_np.sqrt(2), 1/_np.sqrt(2), 0.], [0., 0., 0., 1.]], complex)
+    
+    #cross-resonance gate (exp(-1j*pi/4 sigmaxz))
+    std_unitaries['Gcres'] = _spl.expm(-1j*_np.pi/4*sigmaxz)
+    std_unitaries['Gecres'] = _np.array([[0, 1, 0., 1j], [1., 0, -1j, 0.],
+                                        [0., 1j, 0, 1], [-1j, 0., 1, 0]], complex)/_np.sqrt(2)
+
     std_unitaries['Gzr'] = Gzr()
     std_unitaries['Gczr'] = Gczr()
 
-    #Add these at the end, since we don't want unitary_to_standard_gatenemt to return these "shorthand" names
+    #Add these at the end, since we don't want unitary_to_standard_gatenames to return these "shorthand" names
     std_unitaries['Gx'] = std_unitaries['Gxpi2']
     std_unitaries['Gy'] = std_unitaries['Gypi2']
     std_unitaries['Gz'] = std_unitaries['Gzpi2']
@@ -296,7 +319,7 @@ def standard_gatename_unitaries():
     return std_unitaries
 
 
-def unitary_to_standard_gatename(unitary):
+def unitary_to_standard_gatename(unitary, up_to_phase = False, return_phase = False):
     """
     Looks up and returns the standard gate name for a unitary gate matrix, if one exists.
 
@@ -305,6 +328,16 @@ def unitary_to_standard_gatename(unitary):
     unitary : complex np.array
         The unitary to convert.
 
+    up_to_phase : bool, optional (default False)
+        If true then after checking if the unitary is exactly equivalent to a built-in one, 
+        this then checks if the input unitary is equal to to a built-in one up to a global
+        phase.
+
+    return_phase : bool, optional (default False)
+        If true, and up_to_phase is true, then if a unitary is equivalent up to a global
+        phase to a built-in one, we return that phase (i.e. the phase the built-in one
+        would need to be multiplied by).
+
     Returns
     -------
     str or None
@@ -314,6 +347,28 @@ def unitary_to_standard_gatename(unitary):
     for std_name, U in standard_gatename_unitaries().items():
         if not callable(U) and not callable(unitary) and U.shape == unitary.shape and _np.allclose(unitary, U):
             return std_name
+    
+    #check for equivalence up to a global phase.
+    if up_to_phase:
+        for std_name, U in standard_gatename_unitaries().items():
+        #I think the callable checks are to avoid doing the check on the continuously parameterized Z
+        #rotation that is in the built-in dictionary. Follow the original code's lead and do the same here.
+            if not callable(U) and not callable(unitary) and U.shape == unitary.shape:
+                
+                inv_prod = U.conj().T@unitary
+                inv_prod_diag = _np.diag(inv_prod)
+                inv_prod_upper = _np.triu(inv_prod, 1)
+                inv_prod_lower = _np.tril(inv_prod, -1)
+
+                #If all of the diagonals are close to the same value, and all the the off diagonals
+                #are close to 0 then we should be proportional to the identity.
+                if _np.allclose(inv_prod_diag, inv_prod_diag[0]) and _np.allclose(inv_prod_upper, 0) and _np.allclose(inv_prod_lower, 0):
+                    if return_phase:
+                        phase = inv_prod_diag[0]
+                        return std_name, phase
+                    else:
+                        return std_name
+
     return None
 
 
@@ -334,12 +389,11 @@ def standard_gatenames_cirq_conversions():
 
     Currently there are some standard gate names with no conversion to cirq.
 
-    TODO: add Clifford gates with
-    https://cirq.readthedocs.io/en/latest/generated/cirq.SingleQubitCliffordGate.html
-
     Returns
     -------
-    dict mapping strings to string
+    std_gatenames_to_cirq
+        dict mapping strings corresponding to standard built-in pyGSTi names to
+        corresponding cirq operation objects. 
     """
     try:
         import cirq
@@ -347,7 +401,10 @@ def standard_gatenames_cirq_conversions():
         raise ImportError("Cirq is required for this operation, and it does not appear to be installed.")
 
     std_gatenames_to_cirq = {}
-    std_gatenames_to_cirq['Gi'] = None
+
+    #single-qubit gates
+
+    std_gatenames_to_cirq['Gi'] = cirq.I
     std_gatenames_to_cirq['Gxpi2'] = cirq.XPowGate(exponent=1 / 2)
     std_gatenames_to_cirq['Gxmpi2'] = cirq.XPowGate(exponent=-1 / 2)
     std_gatenames_to_cirq['Gxpi'] = cirq.X
@@ -362,12 +419,87 @@ def standard_gatenames_cirq_conversions():
     std_gatenames_to_cirq['Gh'] = cirq.H
     std_gatenames_to_cirq['Gt'] = cirq.T
     std_gatenames_to_cirq['Gtdag'] = cirq.T**-1
+    std_gatenames_to_cirq['Gn'] = cirq.PhasedXZGate(axis_phase_exponent=0.14758361765043326, 
+                                                    x_exponent=0.4195693767448338, 
+                                                    z_exponent=-0.2951672353008665)
+
+    #two-qubit gates
+
     std_gatenames_to_cirq['Gcphase'] = cirq.CZ
     std_gatenames_to_cirq['Gcnot'] = cirq.CNOT
     std_gatenames_to_cirq['Gswap'] = cirq.SWAP
+    std_gatenames_to_cirq['Gzz'] = cirq.ZZPowGate(exponent=.5, global_shift=-.5)
+    std_gatenames_to_cirq['Gxx'] = cirq.XXPowGate(exponent=.5, global_shift=-.5)
+    std_gatenames_to_cirq['Giswap'] = cirq.ISWAP
+    std_gatenames_to_cirq['Gsqrtiswap'] = cirq.SQRT_ISWAP
+    #I don't presently see a one-to-one conversion for cross-resonance
+
+    #single-qubit clifford group
+
+    std_gatenames_to_cirq['Gc0'] = cirq.I # This is Gi
+    std_gatenames_to_cirq['Gc1'] = cirq.PhasedXZGate(axis_phase_exponent=0.0, x_exponent=0.5, z_exponent=0.5)
+    std_gatenames_to_cirq['Gc2'] = cirq.PhasedXZGate(axis_phase_exponent=0.5, x_exponent=-0.5, z_exponent=-0.5)
+    std_gatenames_to_cirq['Gc3'] = cirq.X # This is pauli X
+    std_gatenames_to_cirq['Gc4'] = cirq.PhasedXZGate(axis_phase_exponent=0.0, x_exponent=-0.5, z_exponent=0.5)
+    std_gatenames_to_cirq['Gc5'] = cirq.PhasedXZGate(axis_phase_exponent=0.5, x_exponent=-0.5, z_exponent=0.5)
+    std_gatenames_to_cirq['Gc6'] = cirq.Y # This is pauli Y
+    std_gatenames_to_cirq['Gc7'] = cirq.PhasedXZGate(axis_phase_exponent=0.0, x_exponent=0.5, z_exponent=-0.5)
+    std_gatenames_to_cirq['Gc8'] = cirq.PhasedXZGate(axis_phase_exponent=0.5, x_exponent=0.5, z_exponent=-0.5)
+    std_gatenames_to_cirq['Gc9'] = cirq.Z # This is pauli Z
+    std_gatenames_to_cirq['Gc10'] = cirq.PhasedXZGate(axis_phase_exponent=0.0, x_exponent=-0.5, z_exponent=-0.5)
+    std_gatenames_to_cirq['Gc11'] = cirq.PhasedXZGate(axis_phase_exponent=0.5, x_exponent=0.5, z_exponent=0.5)
+    std_gatenames_to_cirq['Gc12'] = cirq.H # This is Gh
+    std_gatenames_to_cirq['Gc13'] = cirq.PhasedXZGate(axis_phase_exponent=0.0, x_exponent=-0.5, z_exponent=0.0) # This is Gxmpi2 (up to phase)
+    std_gatenames_to_cirq['Gc14'] = cirq.PhasedXZGate(axis_phase_exponent=0.0, x_exponent=0.0, z_exponent=0.5) # THis is Gzpi2 / Gp (up to phase)
+    std_gatenames_to_cirq['Gc15'] = cirq.PhasedXZGate(axis_phase_exponent=0.5, x_exponent=-0.5, z_exponent=0.0)# This is Gympi2 (up to phase)
+    std_gatenames_to_cirq['Gc16'] = cirq.PhasedXZGate(axis_phase_exponent=0.0, x_exponent=0.5, z_exponent=0.0)# This is Gxpi2 (up to phase)
+    std_gatenames_to_cirq['Gc17'] = cirq.PhasedXZGate(axis_phase_exponent=0.25, x_exponent=1.0, z_exponent=0.0)# This is Gypi2 (up to phase)
+    std_gatenames_to_cirq['Gc18'] = cirq.PhasedXZGate(axis_phase_exponent=0.5, x_exponent=0.5, z_exponent=1.0)
+    std_gatenames_to_cirq['Gc19'] = cirq.PhasedXZGate(axis_phase_exponent=0.0, x_exponent=-0.5, z_exponent=1.0)
+    std_gatenames_to_cirq['Gc20'] = cirq.PhasedXZGate(axis_phase_exponent=-0.25, x_exponent=1.0, z_exponent=0.0)
+    std_gatenames_to_cirq['Gc21'] = cirq.PhasedXZGate(axis_phase_exponent=0.5, x_exponent=0.5, z_exponent=0.0) # This is Gypi2 (up to phase)
+    std_gatenames_to_cirq['Gc22'] = cirq.PhasedXZGate(axis_phase_exponent=0.0, x_exponent=0.5, z_exponent=1.0)
+    std_gatenames_to_cirq['Gc23'] = cirq.PhasedXZGate(axis_phase_exponent=0.0, x_exponent=0.0, z_exponent=-0.5) # This is Gzmpi2 / Gpdag (up to phase)
+
+    #legacy aliasing:
+    std_gatenames_to_cirq['Gx'] = std_gatenames_to_cirq['Gxpi2']
+    std_gatenames_to_cirq['Gy'] = std_gatenames_to_cirq['Gypi2']
+    std_gatenames_to_cirq['Gz'] = std_gatenames_to_cirq['Gzpi2']    
+
 
     return std_gatenames_to_cirq
 
+def cirq_gatenames_standard_conversions():
+    
+    """
+    A dictionary converting cirq gates to built-in pyGSTi names for these gates.
+    Does not currently support conversion of all cirq gate types.
+    """
+
+    try:
+        import cirq
+    except ImportError:
+        raise ImportError("Cirq is required for this operation, and it does not appear to be installed.")
+
+
+    #reverse the mapping in standard_gatenames_cirq_conversions
+    cirq_to_standard_mapping = {value: key for key,value in standard_gatenames_cirq_conversions().items()}
+
+    #A direct reversing doesn't quite do what we want since the originally mapping was not
+    #one-to-one (some pyGSTi gate names refer to the same cirq Circuit, primarily because of the cliffords). 
+    #Manually add back in some preference on the non-one-to-one gates.
+    cirq_to_standard_mapping[cirq.I] = 'Gi'
+    cirq_to_standard_mapping[cirq.X] = 'Gxpi'
+    cirq_to_standard_mapping[cirq.Y] = 'Gypi'
+    cirq_to_standard_mapping[cirq.PhasedXZGate(axis_phase_exponent=0.5, x_exponent=-1, z_exponent=0)] = 'Gypi'
+    cirq_to_standard_mapping[cirq.Z] = 'Gzpi'
+    cirq_to_standard_mapping[cirq.XPowGate(exponent=1 / 2)] = 'Gxpi2'
+    cirq_to_standard_mapping[cirq.YPowGate(exponent=1 / 2)] = 'Gypi2'
+    cirq_to_standard_mapping[cirq.ZPowGate(exponent=1 / 2)] = 'Gzpi2'
+    cirq_to_standard_mapping[cirq.H] = 'Gh'
+
+    return cirq_to_standard_mapping
+
 
 def standard_gatenames_quil_conversions():
     """
@@ -597,6 +729,8 @@ def standard_gatenames_openqasm_conversions(version='u3'):
         std_gatenames_to_qasm['Gc22'] = ['u3(1.570796326794897, 1.570796326794897, 1.570796326794897)']  # [1,1,1]*pi/2
         std_gatenames_to_qasm['Gc23'] = ['u3(0, 0, 4.71238898038469)']  # [0, 0, 3] * pi/2 (this is Gzmpi2 / Gpdag)
 
+        std_gatenames_to_qasm['Gecr'] = ['ecr']
+
         std_gatenames_to_argmap = {}
         std_gatenames_to_argmap['Gzr'] = lambda gatearg: ['u3(0, 0, ' + str(gatearg[0]) + ')']
         std_gatenames_to_argmap['Gczr'] = lambda gatearg: ['crz(' + str(gatearg[0]) + ')']
@@ -650,6 +784,8 @@ def standard_gatenames_openqasm_conversions(version='u3'):
         std_gatenames_to_qasm['Gt'] = ['rz(0.7853981633974485)']
         std_gatenames_to_qasm['Gtdag'] = ['rz(5.497787143782138)']
 
+        std_gatenames_to_qasm['Gecr'] = ['ecr']
+
         std_gatenames_to_argmap = {}
         std_gatenames_to_argmap['Gzr'] = lambda gatearg: ['rz(' + str(gatearg[0]) + ')']
         std_gatenames_to_argmap['Gczr'] = lambda gatearg: ['crz(' + str(gatearg[0]) + ')']

pygsti/tools/jamiolkowski.py

@@ -117,9 +117,9 @@ def jamiolkowski_iso(operation_mx, op_mx_basis='pp', choi_mx_basis='pp'):
     for i in range(M):
         for j in range(M):
             BiBj = _np.kron(BVec[i], _np.conjugate(BVec[j]))
-            BiBj_dag = _np.transpose(_np.conjugate(BiBj))
-            choiMx[i, j] = _mt.trace(_np.dot(opMxInStdBasis, BiBj_dag)) \
-                / _mt.trace(_np.dot(BiBj, BiBj_dag))
+            num = _np.vdot(BiBj, opMxInStdBasis)
+            den = _np.linalg.norm(BiBj) ** 2
+            choiMx[i, j] = num / den 
 
     # This construction results in a Jmx with trace == dim(H) = sqrt(operation_mx.shape[0])
     #  (dimension of density matrix) but we'd like a Jmx with trace == 1, so normalize:
@@ -225,7 +225,7 @@ def fast_jamiolkowski_iso_std(operation_mx, op_mx_basis):
     N2 = opMxInStdBasis.shape[0]; N = int(_np.sqrt(N2))
     assert(N * N == N2)  # make sure N2 is a perfect square
     Jmx = opMxInStdBasis.reshape((N, N, N, N))
-    Jmx = _np.swapaxes(Jmx, 1, 2).flatten()
+    Jmx = _np.swapaxes(Jmx, 1, 2).ravel()
     Jmx = Jmx.reshape((N2, N2))
 
     # This construction results in a Jmx with trace == dim(H) = sqrt(gateMxInPauliBasis.shape[0])
@@ -261,7 +261,7 @@ def fast_jamiolkowski_iso_std_inv(choi_mx, op_mx_basis):
     N2 = choi_mx.shape[0]; N = int(_np.sqrt(N2))
     assert(N * N == N2)  # make sure N2 is a perfect square
     opMxInStdBasis = choi_mx.reshape((N, N, N, N)) * N
-    opMxInStdBasis = _np.swapaxes(opMxInStdBasis, 1, 2).flatten()
+    opMxInStdBasis = _np.swapaxes(opMxInStdBasis, 1, 2).ravel()
     opMxInStdBasis = opMxInStdBasis.reshape((N2, N2))
     op_mx_basis = _bt.create_basis_for_matrix(opMxInStdBasis, op_mx_basis)
 

pygsti/tools/lindbladtools.py

@@ -13,7 +13,6 @@ Utility functions relevant to Lindblad forms and projections
 import numpy as _np
 import scipy.sparse as _sps
 
-from pygsti.tools import matrixtools as _mt
 from pygsti.tools.basistools import basis_matrices
 
 
@@ -84,18 +83,21 @@ def create_elementary_errorgen_dual(typ, p, q=None, sparse=False, normalization_
             rho1 = (p @ rho0 @ qdag + q @ rho0 @ pdag)  # 1 / (2 * d2) *
         elif typ == 'A':
             rho1 = 1j * (p @ rho0 @ qdag - q @ rho0 @ pdag)  # 1j / (2 * d2)
-        elem_errgen[:, i] = rho1.flatten()[:, None] if sparse else rho1.flatten()
+        elem_errgen[:, i] = rho1.ravel()
+        # ^ That line used to branch depending on the value of "sparse", but it
+        #   turns out that both codepaths produced the same result.
 
     return_normalization = bool(normalization_factor == 'auto_return')
     if normalization_factor in ('auto', 'auto_return'):
         primal = create_elementary_errorgen(typ, p, q, sparse)
         if sparse:
-            normalization_factor = _np.vdot(elem_errgen.toarray().flatten(), primal.toarray().flatten())
+            normalization_factor = _np.vdot(elem_errgen.toarray(), primal.toarray())
         else:
-            normalization_factor = _np.vdot(elem_errgen.flatten(), primal.flatten())
+            normalization_factor = _np.vdot(elem_errgen, primal)
     elem_errgen *= _np.real_if_close(1 / normalization_factor).item()  # item() -> scalar
 
-    if sparse: elem_errgen = elem_errgen.tocsr()
+    if sparse:
+        elem_errgen = elem_errgen.tocsr()
     return (elem_errgen, normalization_factor) if return_normalization else elem_errgen
 
 
@@ -134,7 +136,8 @@ def create_elementary_errorgen(typ, p, q=None, sparse=False):
     -------
     ndarray or Scipy CSR matrix
     """
-    d = p.shape[0]; d2 = d**2
+    d = p.shape[0]
+    d2 = d**2
     if sparse:
         elem_errgen = _sps.lil_matrix((d2, d2), dtype=p.dtype)
     else:
@@ -163,10 +166,12 @@ def create_elementary_errorgen(typ, p, q=None, sparse=False):
             rho1 = p @ rho0 @ qdag + q @ rho0 @ pdag - 0.5 * (pq_plus_qp @ rho0 + rho0 @ pq_plus_qp)
         elif typ == 'A':
             rho1 = 1j * (p @ rho0 @ qdag - q @ rho0 @ pdag + 0.5 * (pq_minus_qp @ rho0 + rho0 @ pq_minus_qp))
+        elem_errgen[:, i] = rho1.ravel()
+        # ^ That line used to branch depending on the value of sparse, but both
+        #   branches had the same effect.
 
-        elem_errgen[:, i] = rho1.flatten()[:, None] if sparse else rho1.flatten()
-
-    if sparse: elem_errgen = elem_errgen.tocsr()
+    if sparse:
+        elem_errgen = elem_errgen.tocsr()
     return elem_errgen
 
 def create_lindbladian_term_errorgen(typ, Lm, Ln=None, sparse=False):  # noqa N803
@@ -226,7 +231,10 @@ def create_lindbladian_term_errorgen(typ, Lm, Ln=None, sparse=False):  # noqa N8
         elif typ == 'O':
             rho1 = Ln @ rho0 @ Lm_dag - 0.5 * (Lmdag_Ln @ rho0 + rho0 @ Lmdag_Ln)
         else: raise ValueError("Invalid lindblad term errogen type!")
-        lind_errgen[:, i] = rho1.flatten()[:, None] if sparse else rho1.flatten()
+        lind_errgen[:, i] = rho1.ravel()
+        # ^ That line used to branch based on the value of sparse, but both branches
+        #   produced the same result.
 
-    if sparse: lind_errgen = lind_errgen.tocsr()
+    if sparse:
+        lind_errgen = lind_errgen.tocsr()
     return lind_errgen

pygsti/tools/listtools.py

@@ -383,117 +383,3 @@ def lists_to_tuples(obj):
         return {lists_to_tuples(k): lists_to_tuples(v) for k, v in obj.items()}
     else:
         return obj
-
-
-# ------------------------------------------------------------------------------
-# Machinery initially designed for an in-place take operation, which computes
-# how to do in-place permutations of arrays/lists efficiently.  Kept here
-# commented out in case this is needed some time in the future.
-# ------------------------------------------------------------------------------
-#
-#def build_permute_copy_order(indices):
-#    #Construct a list of the operations needed to "take" indices
-#    # out of an array.
-#
-#    nIndices = len(indices)
-#    flgs = _np.zeros(nIndices,'bool') #flags indicating an index has been processed
-#    shelved = {}
-#    copyList = []
-#
-#    while True: #loop until we've processed everything
-#
-#        #The cycle has ended.  Now find an unprocessed
-#        # destination to begin a new cycle
-#        for i in range(nIndices):
-#            if flgs[i] == False:
-#                if indices[i] == i: # index i is already where it need to be!
-#                    flgs[i] = True
-#                else:
-#                    cycleFirstIndex = iDest = i
-#                    if cycleFirstIndex in indices:
-#                        copyList.append( (-1,i) ) # iDest == -1 means copy to offline storage
-#                    break;
-#        else:
-#            break #everything has been processed -- we're done!
-#
-#        while True: # loop over cycle
-#
-#            # at this point, data for index iDest has been stored or copied
-#            iSrc = indices[iDest] # get source index for current destination
-#
-#            # record appropriate copy command
-#            if iSrc == cycleFirstIndex:
-#                copyList.append( (iDest, -1) ) # copy from offline storage
-#                flgs[iDest] = True
-#
-#                #end of this cycle since we've hit our starting point,
-#                # but no need to shelve first cycle element in this case.
-#                break #(end of cycle)
-#            else:
-#                if iSrc in shelved: #original iSrc is now at index shelved[iSrc]
-#                    iSrc = shelved[iSrc]
-#
-#                copyList.append( (iDest,iSrc) ) # => copy src -> dest
-#                flgs[iDest] = True
-#
-#                if iSrc < nIndices:
-#                    #Continue cycle (swapping within "active" (index < nIndices) region)
-#                    iDest = iSrc # make src the new dest
-#                else:
-#                    #end of this cycle, and first cycle index hasn't been
-#                    # used, so shelve it (store it for later use) if it
-#                    # will be needed in the future.
-#                    if cycleFirstIndex in indices:
-#                        copyList.append( (iSrc,-1) )
-#                        shelved[cycleFirstIndex] = iSrc
-#
-#                    break #(end of cycle)
-#
-#    return copyList
-#
-## X  X     X
-## 0  1  2  3 (nIndices == 4)
-## 3, 0, 7, 4
-## store 0
-## 3 -> 0
-## 4 -> 3
-## stored[0] -> 4, shelved[0] = 4
-## store 1
-## shelved[0]==4 -> 1, NO((stored[1] -> 4, shelved[1] = 4)) B/C don't need index 1
-## store 2
-## 7 -> 2
-## NO((Stored[2] -> 7, istore[2] = 7))
-#
-#
-#def inplace_take(a, indices, axis=None, copyList=None):
-#    check = a.take(indices, axis=axis) #DEBUGGING
-#    return check #FIX FOR NOW = COPY
-#
-#    if axis is None:
-#        def mkindex(i):
-#            return i
-#    else:
-#        def mkindex(i):
-#            sl = [slice(None)] * a.ndim
-#            sl[axis] = i
-#            return sl
-#
-#    if copyList is None:
-#        copyList = build_permute_copy_order(indices)
-#
-#    store = None
-#    for iDest,iSrc in copyList:
-#        if iDest == -1: store = a[mkindex(iSrc)].copy() #otherwise just get a view!
-#        elif iSrc == -1: a[mkindex(iDest)] = store
-#        else: a[mkindex(iDest)] = a[mkindex(iSrc)]
-#
-#    ret = a[mkindex(slice(0,len(indices)))]
-#    if _np.linalg.norm(ret-check) > 1e-8 :
-#        print("ERROR CHECK FAILED")
-#        print("ret = ",ret)
-#        print("check = ",check)
-#        print("diff = ",_np.linalg.norm(ret-check))
-#        assert(False)
-#    #check = None #free mem?
-#    #return ret
-#    return check

pygsti/tools/matrixmod2.py

@@ -468,7 +468,7 @@ def fix_top(a):
     found_B = False
     for ind in range(t):
         aa, P = permute_top(a, ind)
-        B = _np.round_(aa[1:, 1:])
+        B = _np.round(aa[1:, 1:])
 
         if det_mod2(B) == 0:
             continue