quadlib 0.1.0__py3-none-any.whl

quadlib/tools/tensor.py

@@ -0,0 +1,227 @@
+import numpy as np
+
+# Pre-built einsum index strings used by the alternative SOP RHS in
+# propagation/exact.rhs_exact_alt1. Indexed by (ndim, op_type, axis),
+# where op_type is 2 for a matrix operator and 3 for a diagonal operator.
+# Covers ndim = 2..5.
+# fmt: off
+esumstr = {
+    # (dimensions, op type, index); op type 2: matrix, 3: diag matrix
+    (2, 2, 0): 'hj,ji->hi',
+    (2, 2, 1): 'hj,ij->ih',
+
+    (3, 2, 0): 'hj,jik->hik',
+    (3, 2, 1): 'hj,ijk->ihk',
+    (3, 2, 2): 'hj,ikj->ikh',
+
+    (4, 2, 0): 'hj,jikl->hikl',
+    (4, 2, 1): 'hj,ijkl->ihkl',
+    (4, 2, 2): 'hj,ikjl->ikhl',
+    (4, 2, 3): 'hj,iklj->iklh',
+
+    (5, 2, 0): 'hj,jiklm->hiklm',
+    (5, 2, 1): 'hj,ijklm->ihklm',
+    (5, 2, 2): 'hj,ikjlm->ikhlm',
+    (5, 2, 3): 'hj,ikljm->iklhm',
+    (5, 2, 4): 'hj,iklmj->iklmh',
+
+    (2, 3, 0): 'j,ji->ji',
+    (2, 3, 1): 'j,ij->ij',
+
+    (3, 3, 0): 'j,jik->jik',
+    (3, 3, 1): 'j,ijk->ijk',
+    (3, 3, 2): 'j,ikj->ikj',
+
+    (4, 3, 0): 'j,jikl->jikl',
+    (4, 3, 1): 'j,ijkl->ijkl',
+    (4, 3, 2): 'j,ikjl->ikjl',
+    (4, 3, 3): 'j,iklj->iklj',
+
+    (5, 3, 0): 'j,jiklm->jiklm',
+    (5, 3, 1): 'j,ijklm->ijklm',
+    (5, 3, 2): 'j,ikjlm->ikjlm',
+    (5, 3, 3): 'j,ikljm->ikljm',
+    (5, 3, 4): 'j,iklmj->iklmj',
+}
+# fmt: on
+
+
+def _view(a, shape):
+    """Reshape a without copying; the result writes through to a.
+
+    Replaces the in-place ``a.shape = shape`` idiom (deprecated in NumPy
+    2.5), keeping its guarantee: raise instead of silently copying.
+    """
+    v = a.reshape(shape)
+    if not np.shares_memory(v, a):
+        raise ValueError('array cannot be reshaped to ' + str(shape) + ' without a copy')
+    return v
+
+
+def ijk_shape(f, oshape):
+    """
+    change tuple oshape representing a shape to a 3 index tuple collecting
+    indices before and after index f
+    """
+    nmodes = len(oshape)
+    a = np.array(oshape)
+    nshape=[1,1,1]
+    nshape[1] = oshape[f]
+    if f > 0:
+        nshape[0] = a[:f].prod()
+    if f < nmodes - 1:
+        nshape[2] = a[f+1:].prod()
+    return tuple(nshape)
+
+
+def matrix_tensor(M, T):
+    for i in range(0, T.shape[0]):
+        for k in range(0, T.shape[2]):
+            T[i, :, k] = np.dot(M, T[i, :, k])
+    return T
+
+
+def hprod_phi(hlist,nphi,phidim,sdim,phi,hole=None):
+    """
+    Apply matrices in hlist to phi
+       |phi[i]> <= h1.h2.h2....hn |phi[i]>
+
+    hlist - list (or array) of 2D square matrices
+    nphi  - number of tensors in phi
+    phidim- total length of each tensor phi
+    sdim  - shape of each tensor phi[i]
+    phi   - 1D array, a list of tensors phi[i] (input/output)
+    hole  - integer, hlist[hole] is skipped
+
+    The operations are accumulated in phi, i.e. phi is modified in place.
+    - note: phi must be conformable to (nphi,phidim) or (nphi,prod(sdim))
+    """
+    phi2 = _view(phi, (nphi, phidim))
+    for i in range(nphi):
+        for l,hmat in enumerate(hlist):
+            if l == hole: continue
+            matrix_tensor_alt(l,sdim,hmat,phi2[i])
+
+
+def hprod_phi2(hlist,nphi,sdim1,sdim2,phi,hole=None):
+    """
+    Apply matrices in hlist to phi
+       |traphi[i]> = h1.h2.h2....hn |phi[i]>
+
+    hlist - list (or array) of 2D matrices. NEED NOT BE SQUARE.
+    nphi  - number of tensors in phi
+    phidim- total length of each tensor phi
+    sdim1  - shape of each tensor on output (first dimension of each matrix)
+    sdim2  - shape of each tensor on input (second dimension of each matrix)
+    phi   - 1D array, a list of tensors phi[i] (input)
+    hole  - integer, hlist[hole] is skipped
+
+    traphi - transformed phi (output)
+    """
+    phic = phi.copy()
+    philen1 = 1
+    for i in sdim1: philen1 = philen1*i
+    philen2 = 1
+    for i in sdim2: philen2 = philen2*i
+    phic = phic.reshape((nphi, philen2))
+    traphi = []
+    for i in range(nphi):
+        phiold = phic[i]
+        sdimold = list(sdim2)
+        for l,hmat in enumerate(hlist):
+            if l == hole: continue
+            phinew = matrix_tensor2(l,sdimold,hmat,phiold)
+            phiold = phinew
+            sdimold[l] = sdim1[l]
+        traphi.append(phiold)
+    traphi = np.array(traphi)
+    return traphi.flatten()
+
+
+def matrix_tensor_alt(m,sdim,mat,phi):
+    """
+    Perform a matrix tensor multiplication on index m of tensor phi
+
+    m    - input, index summed over
+    sdim - input, dimensions (shape) of phi when in tesorized form
+    mat  - input, 2D square array
+    phi  - input/output, 1D array conformable to the sdim shape
+
+    phi(I,i,K) <= sum_j mat(i,j)*phi(I,j,K)
+    """
+    ijk = ijk_shape(m,sdim)
+    p = _view(phi, ijk)
+    for i in range(ijk[0]):
+        for k in range(ijk[2]):
+            p[i,:,k] = np.dot(mat,p[i,:,k])
+
+
+def matrix_tensor2(m,sdim,mat,phi):
+    """
+    Perform a matrix tensor multiplication on index m of tensor phi
+
+    m    - input, index summed over
+    sdim - input, dimensions (shape) of phi when in tesorized form
+    mat  - input, 2D array, need not be square
+    phi  - input/output, 1D array conformable to the sdim shape
+
+    The length of the multiplied index changes if the first dimension
+    of mat is not equal to the second dimension.
+    phiout(I,i,K) <= sum_j mat(i,j)*phi(I,j,K)
+    """
+    ijk = ijk_shape(m,sdim)
+    ilk = list(ijk)
+    ilk[1] = mat.shape[0]
+    ilk = tuple(ilk)
+    phiout = np.empty(ilk,complex)
+    p = phi.reshape(ijk)
+    for i in range(ijk[0]):
+        for k in range(ijk[2]):
+            phiout[i,:,k] = np.dot(mat,p[i,:,k])
+    return phiout.flatten()
+
+
+def vector_tensor(m,sdim,vec,phi):
+    """
+    Perform a vector tensor multiplication on index m of tensor phi
+
+    m    - input, index summed over
+    sdim - input, dimensions (shape) of phi when in tesorized form
+    mat  - input, 1D
+    phi  - input/output, 1D array conformable to the sdim shape
+
+    hphi(I,j,K) <= vec(j)*phi(I,j,K)
+    """
+    ijk = ijk_shape(m,sdim)
+    p = _view(phi, ijk)
+    for i in range(ijk[0]):
+        for k in range(ijk[2]):
+            p[i,:,k] = vec*p[i,:,k]
+    return phi
+
+
+def compute_density(dm,f,sdim,ten1,ten2=None):
+    """
+    Calculate the density matrix for axis f of tensors ten1 and ten2
+
+    dm: density matrix, output
+    f: integer, axis to be used for the density
+    sdim: dimensions of ten1 and ten2
+    ten1: array conformable to ten1.shape=sdim
+    ten2: if not given ten2=ten1
+    """
+    if ten2 is None: ten2=ten1
+    l = len(sdim)
+    ax = list(range(f)) + list(range(f+1,l))
+    t1 = ten1.reshape(sdim)
+    t2 = ten2.reshape(sdim)
+    dm[:] = np.tensordot(t1.conjugate(),t2,axes=(ax,ax))
+
+
+def overlap(avecs,bvecs):
+    """
+    Compute the overlap matrix from two two-dimensional np.array
+    avecs and bvecs need only to conform in the second index (index 1)
+    """
+    return np.tensordot(avecs.conjugate(),bvecs,axes=(1,1))
+

quadlib/wavefunction/wfn_cpd.py

@@ -0,0 +1,266 @@
+# QuaDLib: QUAntum Dynamics LIBrary for research and methods development
+# Copyright (C) 2018-2026, The Theoretical Chemistry Group, Heidelberg University
+#
+# This software is licensed under the MIT License (https://spdx.org/licenses/MIT.html)
+
+import numpy as np
+
+import quadlib.tools.linalg as linalg
+from quadlib.operator.sop import SumOfProducts
+
+
+class WfnCPD:
+    """
+    Return a CPD wavefunction
+
+    - pdim: list/tuple, primitive dimension of each degree of freedom
+    - rank: number of product terms
+    """
+    def __init__(self, pdim: list[int], rank: int, datatype: type = complex):
+        self.psi = empty_cpd(pdim, rank, datatype=datatype) # psi[0] -> A-vec, psi[1] -> SPFs_1, etc.
+        self.ndof = len(pdim)
+        self.pdim = pdim
+        self.rank = rank
+        self.hamiltonian = None
+        self.time = 0.0
+        self._overlaps = []
+        self._hterms = None
+
+    def _update_overlaps(self):
+        self._overlaps = cpd_overlap_tensor(self.psi, self.psi)
+
+    def _coeff(self):
+        return np.asarray(self.hamiltonian.coeff, dtype=complex)
+
+    def _update_hterms(self):
+        assert isinstance(self.hamiltonian, SumOfProducts)
+        self._hterms = cpd_hterms_tensor(self.psi, self.psi, self.hamiltonian)
+ 
+    def norm(self):
+        self._update_overlaps()
+        Nm = cpd_overlap_prod(self._overlaps)
+        norm = np.sum(Nm)
+        norm = np.real(norm)**0.5
+        return norm
+
+    def normalize(self):
+        N = self.norm()
+        self.psi[-1] = self.psi[-1]/N
+
+    def overlap(self, other):
+        tensor = cpd_overlap_tensor(self.psi, other.psi)
+        overlap_matrix = cpd_overlap_prod(tensor)
+        ovl = np.sum(overlap_matrix)
+        return ovl
+
+    def build_hartree(self, spfs, datatype=complex):
+        """
+        Build a Hartree product state with the list of spfs, one per DOF 
+
+        All other SPFs are set random normalized
+        All A-vector entris are set to zero except A[0]=1.0
+        """
+        for j in range(self.ndof):
+            rand_spfs = linalg.random_normal_columns_matrix(self.pdim[j], self.rank, datatype)
+            self.psi[j] = rand_spfs.T
+            self.psi[j][0] = spfs[j][:] # copy contents to avoid accidental modification
+        self.psi[-1][0] = 1.0  # A[0] = 1.0 
+
+    def build_hartree_list(self, spfs_list, datatype=complex):
+        """
+        Take a list of Hartree products as input and set the corresponding SPFs
+
+        All other SPFs are set random normalized
+        All A-vector entris are set to zero except A[0]=1.0
+        """
+        nhartree = len(spfs_list)
+        for j in range(self.ndof):
+            rand_spfs = linalg.random_normal_columns_matrix(self.pdim[j], self.rank, datatype)
+            self.psi[j] = rand_spfs.T
+            for k in range(nhartree):
+                self.psi[j][k] = np.copy(spfs_list[k][j]) # copy contents to avoid accidental modification
+        for k in range(nhartree):
+            self.psi[-1][k] = 1.0  # A[k] = 1.0
+        self.normalize()
+
+    def density1d(self, dof):
+        """
+        Return 1d density matrix for dof in the primitive repr.
+
+        den1d[a, b] = sum Psi(..a..) Psi*(..b..), so that <O> = Tr(den1d O).
+        """
+        rho = self.rho_matrix(dof)  # rho[i, j] = A_i* A_j prod_{d != dof} <phi_i|phi_j>
+        spfs = self.psi[dof]
+        return spfs.T @ rho.T @ spfs.conj()
+
+    def expval1d(self, op, dof):
+        """
+        Return expectation value of operator op for degree of freedom dof
+        """
+        den1d = self.density1d(dof)
+        expval = np.trace(den1d @ op)  # <o> = Tr[rho, oper] for 1D operators
+        return expval
+ 
+    def S_matrix(self): # S -> configuration overlap matrix
+        self._update_overlaps()
+        S = cpd_overlap_prod(self._overlaps, hole=-1)
+        return S
+
+    def rho_matrix(self, dof): # rho -> density matrix
+        self._update_overlaps()
+        R = cpd_overlap_prod(self._overlaps, hole=dof)
+        return R
+
+    def H_matrix(self):
+        """
+        Compute Hamiltonian in the representation of the configurations
+        """
+        self._update_hterms()
+        hmat = np.prod(self._hterms, axis=1)
+        hmat = np.einsum('k,kij->kij', self._coeff(), hmat)
+        return hmat
+
+    def A_density(self):
+        """
+        Density matrix including only the A-vector entries
+        """
+        return np.outer(self.psi[-1].conj(), self.psi[-1])
+
+    def rhs_A(self):
+        """
+        Time derivative of the A-vector with the SPFs frozen
+
+        S dA/dt = -i H A, with S and H in the (non-orthogonal)
+        configuration basis. The coupled equations with moving SPFs are
+        in quadlib.experimental.cpd_eom.
+        """
+        S1 = linalg.invert_reg(self.S_matrix())[0]
+        H = self.H_matrix().sum(axis=0)
+        return -1.0j * S1 @ (H @ self.psi[-1])
+
+    def nullspace_dim(self, tol=None):
+        """
+        Dimension of the null space of the CPD parametrization at the
+        current state; see cpd_nullspace_dim.
+        """
+        return cpd_nullspace_dim(self.psi, tol=tol)
+
+def empty_cpd(pdim, rank, datatype=complex):
+    cpd = [] # List containing the A-vector and the SPF matrices for each DOF
+    for d in pdim:
+        spfs = np.zeros((rank, d), datatype) # each SPF stored as a ROW
+        cpd.append(spfs)
+    cpd.append(np.zeros(rank, datatype))  # A-vector comes last
+    return cpd
+
+def cpd_overlap_tensor(bra, ket):
+    ovl = []
+    for nu in range(len(bra) - 1):
+        ovl.append(bra[nu].conj() @ ket[nu].T)
+    ovl.append(np.outer(bra[-1].conj(), ket[-1]))
+    return np.asarray(ovl)
+
+def cpd_overlap_prod(tensor, hole=None):
+    if hole is None:
+        matr = np.prod(tensor, axis=0)
+    elif type(hole) is int:
+        t = np.ones(tensor.shape, bool)
+        t[hole,:] = False
+        matr = np.prod(tensor, axis=0, where=t)
+    else:
+        raise ValueError()
+    return matr
+
+def cpd_hterms_tensor(bra, ket, oper):
+    """
+    Representation of the operator in the space of the SPFs (hterms in MCTDH)
+
+    bra -- psi attribute of WfnCPD
+
+    Notes:
+        The coefficients oper.coeff are NOT included; the caller applies them.
+    """
+    oprank = len(oper.terms)
+    ndofs = oper.ndofs
+    hterms = []
+    for k in range(oprank):
+        hk = []
+        for d in range(ndofs):
+            hkd = oper.matrix_element_term(k, d, bra[d], ket[d])
+            hk.append(hkd)
+        hterms.append(hk)
+    return np.asarray(hterms)
+
+
+def cpd_jacobian(psi):
+    """
+    Jacobian of the full-space vector of a CPD wavefunction with respect
+    to all its parameters
+
+    Psi = sum_j A_j phi_{1,j} (x) phi_{2,j} (x) ... (x) phi_{f,j}
+
+    psi -- psi attribute of WfnCPD: SPF matrices psi[d] of shape
+           (rank, n_d), one SPF per row, and the A-vector psi[-1]
+
+    Returns J of shape (prod n_d, rank * (1 + sum n_d)), complex. Psi is
+    a holomorphic function of the complex parameters, so J is the
+    complex-linear derivative dPsi/dp. Column order: the R entries of A,
+    then for each DOF d and configuration j the n_d components of
+    phi_{d,j}. Rows follow the full product space in C order (first DOF
+    slowest), as in SumOfProducts.full_matrix_operator.
+
+    The full product space is built explicitly: memory scales as
+    prod(n_d) * rank * (1 + sum n_d).
+    """
+    spfs, A = psi[:-1], psi[-1]
+    rank = len(A)
+    cols = []
+    for j in range(rank):  # dPsi/dA_j = Phi_j
+        cols.append(linalg.kron_list([s[j][:, None] for s in spfs]))
+    for d, sd in enumerate(spfs):  # dPsi/dphi_{d,j} = A_j Phi_j with phi_{d,j} -> 1
+        for j in range(rank):
+            factors = [s[j][:, None] for s in spfs]
+            factors[d] = np.eye(sd.shape[1])
+            cols.append(A[j] * linalg.kron_list(factors))
+    return np.hstack(cols)
+
+
+def cpd_nullspace_dim(psi, tol=None):
+    """
+    Dimension of the null space of the CPD parametrization at psi
+
+    The null space of the Jacobian (cpd_jacobian) collects the parameter
+    changes that leave Psi unchanged to first order: the redundancy
+    (gauge freedom) of the ansatz at this point. It makes the linear
+    system for the parameter time derivatives in variational equations
+    of motion singular unless a gauge condition removes it.
+
+    Known counts, for generic (e.g. random) parameters, all complex:
+    - per configuration j, rescaling phi_{d,j} -> (1 + e_d) phi_{d,j} and
+      A_j -> (1 - sum_d e_d) A_j leaves Psi unchanged: at least f * rank;
+    - f >= 3 and parameters that do not saturate the product space:
+      exactly f * rank;
+    - f = 2 and R <= min(n_1, n_2): Psi is a rank-R matrix whose
+      factorization has an extra GL(R) freedom; the null space is
+      n_params - R (n_1 + n_2 - R);
+    - the Jacobian rank never exceeds prod(n_d): if n_params - f * rank
+      exceeds it, the null space is at least n_params - prod(n_d);
+    - defective formats fall below min(prod(n_d), n_params - f * rank),
+      the naive expectation for the rank. The classical example is
+      3 x 3 x 3 at rank 4 (Strassen): rank 26 instead of 27, null space
+      14 instead of 13.
+    Special points (e.g. some A_j = 0) have larger null spaces. For the
+    generic count of an ansatz, evaluate at random parameters.
+
+    psi -- psi attribute of WfnCPD (see cpd_jacobian)
+    tol -- singular-value threshold for the rank; default: that of
+           numpy.linalg.matrix_rank (relative to the largest singular
+           value)
+
+    Returns (null_dim, n_params, jacobian_rank), counted in complex
+    dimensions.
+    """
+    J = cpd_jacobian(psi)
+    jac_rank = int(np.linalg.matrix_rank(J, tol=tol))
+    n_params = J.shape[1]
+    return n_params - jac_rank, n_params, jac_rank

quadlib/wavefunction/wfn_exact.py

@@ -0,0 +1,147 @@
+# QuaDLib: QUAntum Dynamics LIBrary for research and methods development
+# Copyright (C) 2018-2026, The Theoretical Chemistry Group, Heidelberg University
+#
+# This software is licensed under the MIT License (https://spdx.org/licenses/MIT.html)
+
+"""
+Exact (full-tensor) wavefunction.
+
+WfnExact holds psi as an array of shape pdim (one index per degree of
+freedom) and propagates it with quadlib.propagation.propagate_exact.
+The free functions below work on plain arrays and implement the
+corresponding WfnExact methods.
+"""
+
+import numpy as np
+
+import quadlib.tools.constants as cv
+import quadlib.tools.tensor as tens
+from quadlib.propagation.exact import propagate_exact
+
+
+class WfnExact:
+    """
+    Full-tensor wavefunction psi[i1, i2, ..., if]
+
+    pdim -- primitive dimension of each degree of freedom
+    """
+    def __init__(self, pdim, dtype=complex):
+        self.pdim = tuple(int(n) for n in pdim)
+        self.psi = np.zeros(self.pdim, dtype)
+        self.psi0 = None     # reference state for the autocorrelation
+        self.t = 0.0
+        self.dt = 1.0        # output interval of propagate()
+        self.time_list = []
+        self.auto_list = []
+        self.psi_list = []
+
+    @classmethod
+    def from_product(cls, vecs, dtype=complex):
+        """Product state from one 1D vector per degree of freedom."""
+        w = cls([len(v) for v in vecs], dtype)
+        w.psi[:] = product_state_exact(vecs).reshape(w.pdim)
+        return w
+
+    @property
+    def len(self):
+        return self.psi.size
+
+    def reset_initial(self):
+        """Take the current psi and t as the reference for auto(t)."""
+        self.psi0 = self.psi.copy()
+        self.time_list = [self.t]
+        self.auto_list = [self.auto()]
+        self.psi_list = []
+
+    def norm(self):
+        return np.sqrt(np.real(np.vdot(self.psi, self.psi)))
+
+    def auto(self):
+        """Autocorrelation <psi0|psi(t)>."""
+        return np.vdot(self.psi0, self.psi)
+
+    def density1d(self, dof):
+        return density1d(self.psi, dof)
+
+    def expval1d(self, op, dof):
+        return expval1d(self.psi, op, dof)
+
+    def propagate(self, final_time, operator, *, auto=True, psi=False, **opts):
+        """
+        Propagate exactly from self.t to final_time
+
+        Output every self.dt, appended to self.time_list, self.auto_list
+        (if auto) and self.psi_list (if psi). reset_initial() is called
+        first if no reference state has been set. opts go to
+        quadlib.propagation.propagate_exact (solver, and for 'zvode'
+        method, atol, rtol, maxstep).
+        """
+        if self.psi0 is None:
+            self.reset_initial()
+        observables = {}
+        if auto:
+            psi0 = self.psi0.ravel()
+            observables['auto'] = lambda t, y: np.vdot(psi0, y)
+        out = propagate_exact(self.psi, operator, self.dt, final_time,
+                              tinit=self.t, store_psi=psi,
+                              observables=observables, **opts)
+        self.time_list.extend(out['time'][1:])
+        if auto:
+            self.auto_list.extend(out['auto'][1:])
+        if psi:
+            self.psi_list.extend(out['psi'][1:])
+        self.psi = out['final']
+        self.t = out['time'][-1]
+        return out
+
+    def plauto(self):
+        """Plot the autocorrelation function (time in fs)."""
+        import matplotlib.pyplot as plt
+
+        if not self.auto_list:
+            raise ValueError('plauto: missing auto in wavefunction\n')
+        t = np.asarray(self.time_list)
+        a = np.asarray(self.auto_list)
+        plt.plot(t*cv.au2fs, np.real(a), label='Re')
+        plt.plot(t*cv.au2fs, np.imag(a), label='Im')
+        plt.plot(t*cv.au2fs, np.abs(a), label='Abs')
+        plt.legend()
+        plt.title('auto')
+        plt.show()
+
+
+def product_state_exact(vec_list):
+    """
+    Take list of 1D state vectors and create the product state
+    """
+    state_vec = vec_list[0]
+    for v in vec_list[1:]:
+        state_vec = np.outer(state_vec, v)
+    return state_vec.flatten()
+
+def density1d(A, dof):
+    """
+    Return density matrix for degree of freedom dof
+
+    A -- multidimensional array of shape (n1, n2, ...)
+
+    Return density matrix d1d[a, b] = sum A(..a..) A*(..b..), so that
+    <O> = Tr(d1d O)
+    """
+    ijk = tens.ijk_shape(dof, A.shape)
+    Ar = A.reshape(ijk)
+    return np.einsum('ijk,ilk->jl', Ar, Ar.conj())
+
+def expval1d(A, op, dof):
+    """
+    Return expectation value for operator op on dof
+
+    A -- multidimensional array of shape (n1, n2, ...)
+    op -- (nDOF, nDOF) matrix
+
+    Return expectation value
+    """
+    ijk = tens.ijk_shape(dof, A.shape)
+    Ar = A.reshape(ijk)
+    opA = np.einsum('ij,kjm->kim', op, Ar)
+    return np.vdot(Ar, opA)