tequila-basic 1.8.9__py3-none-any.whl → 1.9.1__py3-none-any.whl

tequila/circuit/_gates_impl.py

@@ -6,7 +6,7 @@ from tequila.utils.exceptions import TequilaException
 from tequila.objective.objective import Variable, FixedVariable, assign_variable
 from tequila.hamiltonian import PauliString, QubitHamiltonian, paulis
 from tequila.tools import list_assignment
-from numpy import pi, sqrt
+import numpy as np
 
 from dataclasses import dataclass
 
@@ -234,12 +234,12 @@ class DifferentiableGateImpl(ParametrizedGateImpl):
         if r is None:
             r = self.eigenvalues_magnitude
 
-        s =  pi / (4 * r)
+        s =  np.pi / (4 * r)
         if self.is_controlled() and not self.assume_real:
             # following https://arxiv.org/abs/2104.05695
             shifts = [s, -s, 3 * s, -3 * s]
-            coeff1 = (sqrt(2) + 1)/sqrt(8) * r
-            coeff2 = (sqrt(2) - 1)/sqrt(8) * r
+            coeff1 = (np.sqrt(2) + 1)/np.sqrt(8) * r
+            coeff2 = (np.sqrt(2) - 1)/np.sqrt(8) * r
             coefficients = [coeff1, -coeff1, -coeff2, coeff2]
             circuits = []
             for i, shift in enumerate(shifts):
@@ -344,7 +344,7 @@ class PowerGateImpl(ParametrizedGateImpl):
 
     @property
     def power(self):
-        return self.parameter/pi
+        return self.parameter/np.pi
 
     def __init__(self, name, generator: QubitHamiltonian,  target: list, power, control: list = None):
         if generator is None:
@@ -353,7 +353,7 @@ class PowerGateImpl(ParametrizedGateImpl):
         if name is None:
             assert generator is not None
             name = str(generator)
-        super().__init__(name=name, parameter=power * pi, target=target, control=control, generator=generator)
+        super().__init__(name=name, parameter=power * np.pi, target=target, control=control, generator=generator)
 
 
 class GeneralizedRotationImpl(DifferentiableGateImpl):
@@ -376,11 +376,44 @@ class GeneralizedRotationImpl(DifferentiableGateImpl):
             targets += [k for k in ps.keys()]
         return tuple(set(targets))
 
-    def __init__(self, angle, generator, control=None, eigenvalues_magnitude=0.5, steps=1, assume_real=False):
-        super().__init__(eigenvalues_magnitude=eigenvalues_magnitude, assume_real=assume_real, name="GenRot", parameter=angle, target=self.extract_targets(generator), control=control)
+    def __init__(self, angle, generator, p0=None, control=None, target=None, eigenvalues_magnitude=0.5, steps=1, name="GenRot", assume_real=False):
+        if target == None:
+            target = self.extract_targets(generator)
+        super().__init__(eigenvalues_magnitude=eigenvalues_magnitude, generator=generator, assume_real=assume_real, name=name, parameter=angle, target=target, control=control)
         self.steps = steps
-        self.generator = generator
+        if control is None and p0 is not None:
+            # augment p0 for control qubits
+            # Qp = 1/2(1+Z) = |0><0|
+            p0 = p0*paulis.Qp(control)
+        self.p0 = p0
+        
+    def shifted_gates(self):
+        if not self.assume_real:
+            # following https://arxiv.org/abs/2104.05695
+            s = 0.5 * np.pi
+            shifts = [s, -s, 3 * s, -3 * s]
+            coeff1 = 0.25 * (np.sqrt(2) + 1)/np.sqrt(2)
+            coeff2 = 0.25 * (np.sqrt(2) - 1)/np.sqrt(2)
+            coefficients = [coeff1, -coeff1, -coeff2, coeff2]
+            circuits = []
+            for i, shift in enumerate(shifts):
+                shifted_gate = copy.deepcopy(self)
+                shifted_gate.parameter += shift
+                circuits.append((coefficients[i], shifted_gate))
+            return circuits
 
+        r = 0.25
+        s = 0.5*np.pi
+        
+        Up1 = copy.deepcopy(self)
+        Up1._parameter = self.parameter+s
+        Up2 = GeneralizedRotationImpl(angle=s, generator=self.p0, eigenvalues_magnitude=r) # controls are in p0
+        Um1 = copy.deepcopy(self)
+        Um1._parameter = self.parameter-s
+        Um2 = GeneralizedRotationImpl(angle=-s, generator=self.p0, eigenvalues_magnitude=r) # controls are in p0
+
+        return [(2.0 * r, [Up1,  Up2]), (-2.0 * r, [Um1, Um2])]
+        
 class ExponentialPauliGateImpl(DifferentiableGateImpl):
     """
     Same convention as for rotation gates:

tequila/circuit/gates.py

@@ -361,10 +361,13 @@ def Rp(paulistring: typing.Union[PauliString, str], angle, control: typing.Union
     return ExpPauli(paulistring=paulistring, angle=angle, control=control, *args, **kwargs)
 
 
+def GenRot(*args, **kwargs):
+    return GeneralizedRotation(*args, **kwargs)
+
 def GeneralizedRotation(angle: typing.Union[typing.List[typing.Hashable], typing.List[numbers.Real]],
                         generator: QubitHamiltonian,
                         control: typing.Union[list, int] = None,
-                        eigenvalues_magnitude: float = 0.5,
+                        eigenvalues_magnitude: float = 0.5, p0=None,
                         steps: int = 1, assume_real=False) -> QCircuit:
     """
 
@@ -393,6 +396,8 @@ def GeneralizedRotation(angle: typing.Union[typing.List[typing.Hashable], typing
         list of control qubits
     eigenvalues_magnitude
         magnitude of eigenvalues, in most papers referred to as "r" (default 0.5)
+    p0
+        possible nullspace projector (if the rotation is happens in Q = 1-P0). See arxiv:2011.05938
     steps
         possible Trotterization steps (default 1)
 
@@ -403,7 +408,7 @@ def GeneralizedRotation(angle: typing.Union[typing.List[typing.Hashable], typing
 
     return QCircuit.wrap_gate(
         impl.GeneralizedRotationImpl(angle=assign_variable(angle), generator=generator, control=control,
-                                eigenvalues_magnitude=eigenvalues_magnitude, steps=steps, assume_real=assume_real))
+                                eigenvalues_magnitude=eigenvalues_magnitude, steps=steps, assume_real=assume_real, p0=p0))
 
 
 
@@ -473,7 +478,7 @@ def Trotterized(generator: QubitHamiltonian = None,
     return QCircuit.wrap_gate(impl.TrotterizedGateImpl(generator=generator, angle=angle, steps=steps, control=control, randomize=randomize, **kwargs))
 
 
-def SWAP(first: int, second: int, control: typing.Union[int, list] = None, power: float = None, *args,
+def SWAP(first: int, second: int, angle: float = None, control: typing.Union[int, list] = None, power: float = None, *args,
          **kwargs) -> QCircuit:
     """
     Notes
@@ -486,10 +491,12 @@ def SWAP(first: int, second: int, control: typing.Union[int, list] = None, power
         target qubit
     second: int
         target qubit
+    angle: numeric type or hashable type
+        exponent in the for e^{-i a/2 G}
     control
         int or list of ints
     power
-        numeric type (fixed exponent) or hashable type (parametrized exponent)
+        numeric type (fixed exponent) or hashable type (parametrized exponent in the form (SWAP)^n
 
     Returns
     -------
@@ -498,12 +505,82 @@ def SWAP(first: int, second: int, control: typing.Union[int, list] = None, power
     """
 
     target = [first, second]
+    if angle is not None:
+        assert power is None
+        angle = assign_variable(angle)
+    elif power is not None:
+        angle = assign_variable(power)*np.pi
     generator = 0.5 * (paulis.X(target) + paulis.Y(target) + paulis.Z(target) - paulis.I(target))
-    if power is None or power in [1, 1.0]:
+    if angle is None or power in [1, 1.0]:
         return QGate(name="SWAP", target=target, control=control, generator=generator)
     else:
-        return GeneralizedRotation(angle=power * np.pi, control=control, generator=generator,
+        return GeneralizedRotation(angle=angle, control=control, generator=generator,
                                    eigenvalues_magnitude=0.25)
+        
+        
+def iSWAP(first: int, second: int, control: typing.Union[int, list] = None, power: float = 1.0, *args,
+         **kwargs) -> QCircuit:
+    """
+    Notes
+    ----------
+    iSWAP gate
+    .. math::
+        iSWAP = e^{i\\frac{\\pi}{4} (X \\otimes X + Y \\otimes Y )}
+
+    Parameters
+    ----------
+    first: int
+        target qubit
+    second: int
+        target qubit
+    control
+        int or list of ints
+    power
+        numeric type (fixed exponent) or hashable type (parametrized exponent)
+
+    Returns
+    -------
+    QCircuit
+
+    """
+
+    generator = paulis.from_string(f"X({first})X({second}) + Y({first})Y({second})")
+    
+    p0 = paulis.Projector("|00>") + paulis.Projector("|11>")
+    p0 = p0.map_qubits({0:first, 1:second})
+
+    gate = QubitExcitationImpl(angle=power*(-np.pi/2), target=generator.qubits, generator=generator, p0=p0, control=control, compile_options="vanilla", *args, **kwargs)
+    
+    return QCircuit.wrap_gate(gate)
+    
+    
+def Givens(first: int, second: int, control: typing.Union[int, list] = None, angle: float = None, *args,
+         **kwargs) -> QCircuit:
+    """
+    Notes
+    ----------
+    Givens gate G
+    .. math::
+        G = e^{-i\\theta \\frac{(Y \\otimes X - X \\otimes Y )}{2}}
+
+    Parameters
+    ----------
+    first: int
+        target qubit
+    second: int
+        target qubit
+    control
+        int or list of ints
+    angle
+        numeric type (fixed exponent) or hashable type (parametrized exponent), theta in the above formula
+
+    Returns
+    -------
+    QCircuit
+
+    """
+
+    return QubitExcitation(target=[second,first], angle=2*angle, control=control, *args, **kwargs)  # twice the angle since theta is not divided by two in the matrix exponential
 
 
 """
@@ -965,11 +1042,7 @@ and should all implement a compile function that
 returns a QCircuit of primitive tq gates
 """
 
-class QubitExcitationImpl(impl.DifferentiableGateImpl):
-
-    @property
-    def steps(self):
-        return 1
+class QubitExcitationImpl(impl.GeneralizedRotationImpl):
 
     def __init__(self, angle, target, generator=None, p0=None, assume_real=True, control=None, compile_options=None):
         angle = assign_variable(angle)
@@ -990,15 +1063,9 @@ class QubitExcitationImpl(impl.DifferentiableGateImpl):
         else:
             assert generator is not None
             assert p0 is not None
-
-        super().__init__(name="QubitExcitation", parameter=angle, target=target, control=control)
-        self.generator = generator
-        if control is not None:
-            # augment p0 for control qubits
-            # Qp = 1/2(1+Z) = |0><0|
-            p0 = p0*paulis.Qp(control)
-        self.p0 = p0
-        self.assume_real = assume_real
+        
+        super().__init__(name="QubitExcitation", angle=angle, generator=generator, target=target, p0=p0, control=control, assume_real=assume_real, steps=1)
+        
         if compile_options is None:
             self.compile_options = "optimize"
         elif hasattr(compile_options, "lower"):
@@ -1007,26 +1074,21 @@ class QubitExcitationImpl(impl.DifferentiableGateImpl):
             self.compile_options = compile_options
 
     def map_qubits(self, qubit_map: dict):
-        mapped_generator = self.generator.map_qubits(qubit_map=qubit_map)
-        mapped_p0 = self.p0.map_qubits(qubit_map=qubit_map)
-        mapped_control = self.control
-        if mapped_control is not None:
-            mapped_control=tuple([qubit_map[i] for i in self.control])
-        result = copy.deepcopy(self)
-        result.generator=mapped_generator
-        result.p0 = mapped_p0
-        result._target = tuple([qubit_map[x] for x in self.target])
-        result._control = mapped_control
-        result.finalize()
-        return result
+        mapped = super().map_qubits(qubit_map)
+        mapped.p0 = self.p0.map_qubits(qubit_map=qubit_map)
+        return mapped
 
     def compile(self, exponential_pauli=False, *args, **kwargs):
         # optimized compiling for single and double qubit excitaitons following arxiv:2005.14475
         # Alternative representation in arxiv:2104.05695 (not implemented -> could be added and controlled with optional compile keywords)
+        if self.is_controlled():
+            control = list(self.control)
+        else:
+            control = []
         if self.compile_options == "optimize" and len(self.target) == 2 and exponential_pauli:
             p,q = self.target
             U0 = X(target=p, control=q)
-            U1 = Ry(angle=self.parameter, target=q, control=p)
+            U1 = Ry(angle=self.parameter, target=q, control=[p]+control)
             return U0 + U1 + U0
         elif self.compile_options == "optimize" and len(self.target) == 4 and exponential_pauli:
             p,r,q,s = self.target
@@ -1035,39 +1097,11 @@ class QubitExcitationImpl(impl.DifferentiableGateImpl):
             U0 += X(target=r, control=p)
             U0 += X(target=q)
             U0 += X(target=s)
-            U1 = Ry(angle=-self.parameter, target=p, control=[q,r,s])
+            U1 = Ry(angle=-self.parameter, target=p, control=[q,r,s]+control)
             return U0 + U1 + U0.dagger()
         else:
-            return Trotterized(angle=self.parameter, generator=self.generator, steps=1)
-
-    def shifted_gates(self):
-        if not self.assume_real:
-            # following https://arxiv.org/abs/2104.05695
-            s = 0.5 * np.pi
-            shifts = [s, -s, 3 * s, -3 * s]
-            coeff1 = 0.25 * (np.sqrt(2) + 1)/np.sqrt(2)
-            coeff2 = 0.25 * (np.sqrt(2) - 1)/np.sqrt(2)
-            coefficients = [coeff1, -coeff1, -coeff2, coeff2]
-            circuits = []
-            for i, shift in enumerate(shifts):
-                shifted_gate = copy.deepcopy(self)
-                shifted_gate.parameter += shift
-                circuits.append((coefficients[i], shifted_gate))
-            return circuits
-
-        r = 0.25
-        s = 0.5*np.pi
-
-        Up1 = copy.deepcopy(self)
-        Up1._parameter = self.parameter+s
-        Up1 = QCircuit.wrap_gate(Up1)
-        Up2 = GeneralizedRotation(angle=s, generator=self.p0, eigenvalues_magnitude=r) # controls are in p0
-        Um1 = copy.deepcopy(self)
-        Um1._parameter = self.parameter-s
-        Um1 = QCircuit.wrap_gate(Um1)
-        Um2 = GeneralizedRotation(angle=-s, generator=self.p0, eigenvalues_magnitude=r) # controls are in p0
-
-        return [(2.0 * r, Up1 +  Up2), (-2.0 * r, Um1 + Um2)]
+            return Trotterized(angle=self.parameter, generator=self.generator, steps=1, control=self.control)
+
 
 def _convert_Paulistring(paulistring: typing.Union[PauliString, str, dict]) -> PauliString:
     '''

tequila/grouping/fermionic_functions.py

@@ -871,22 +871,69 @@ def compute_meas_alloc(varbs, obt=None, tbts=None, n_qubits=None, mix=0.0):
     for i in range(len(meas_alloc)):
         if meas_alloc[i] < 1e-6:
             meas_alloc[i] = 1e-6
-    return np.real( meas_alloc/np.sum(meas_alloc) )
+    return np.real( meas_alloc/np.sum(meas_alloc))
 
-def get_orb_rot(U, tol = 1e-12):
+def depth_eff_order_mf(N):
+    '''
+    Returns index ordering for linear depth circuit
+
+    For example N = 6 gives elimination order
+    [ 0.  0.  0.  0.  0.  0.]
+    [ 7.  0.  0.  0.  0.  0.]
+    [ 5. 10.  0.  0.  0.  0.]
+    [ 3.  8. 12.  0.  0.  0.]
+    [ 2.  6. 11. 14.  0.  0.]
+    [ 1.  4.  9. 13. 15.  0.]
+    '''
+    l = []
+    for c in range(0, N-1):
+        for r in range(1, N):
+            if r - c > 0:
+                l.append([r, c, 2*c - r + N])
+    l.sort(key=lambda x: x[2])
+    return [(a[0], a[1]) for a in l]
+
+def get_orb_rot(U, qubit_list = [], method = 'short', tol = 1e-12):
     '''
     Construct sequence of orbital rotations that implement mean-field unitary given by NxN unitary U
     Currently supported only for real U
     '''
-    U[abs(U) < tol] = 0
-    theta, phi = given_rotation(U, tol)
+    
+    N = len(U)
     C = tq.QCircuit()
-    for i, p in enumerate(phi):
-        C += n_rotation(i, p)
+    
+    if qubit_list == []:
+        qubit_list = list(range(N))
+    
+    assert len(qubit_list) >= len(U), 'Insufficient qubits for orbital rotation' #check if sufficient qubits
+    
+    U[abs(U) < tol] = 0
+
+    if method == 'naive':
+        theta_list, phi_list = given_rotation(U, tol)
+    elif method == 'short':
+        ordering = depth_eff_order_mf(N)
+        theta_list, phi_list = given_rotation(U, tol, ordering)
+    
+    #filter
+    theta_list_new = []
+    for i, theta in enumerate(theta_list):
+        if abs(theta[0] % (2*np.pi)) > tol:
+            theta_list_new.append(theta)
+    
+    phi_list_new = []
+    for i, phi in enumerate(phi_list):
+        if abs(phi[0]) > tol:
+            phi_list_new.append(phi)
+    
+    for phi in phi_list_new:
+        C += n_rotation(qubit_list[phi[1]], phi[0])
+    
     gates = []
-    for th in theta:
-        gates.append(orbital_rotation(th[1], th[2], -th[0]))
+    for theta in theta_list_new:
+        gates.append(orbital_rotation(qubit_list[theta[1]], qubit_list[theta[2]], -theta[0]))
     gates.reverse()
+
     for gate in gates:
         C += gate
     return C
@@ -894,7 +941,7 @@ def get_orb_rot(U, tol = 1e-12):
 def orbital_rotation(i, j, theta):
     '''
     Implements exp(theta(a^_i a_j - a^_j a_i))
-    Right now restricted to |i-j| <= 1
+    Right now restricted to |i-j| <= 1 and jordan wigner transform.
     '''
     if abs(i-j) <= 1:
         return tq.gates.CNOT(control=i, target=j) + tq.gates.Ry(angle=2*theta, target=i, control=j) + tq.gates.CNOT(control=i, target=j)
@@ -902,25 +949,39 @@ def orbital_rotation(i, j, theta):
 def n_rotation(i, phi):
     return tq.gates.Rz(angle = phi, target=i)
 
-def given_rotation(U, tol = 1e-12): #verified
+def given_rotation(U, tol = 1e-12, ordering = None):
     '''
     Decomposes the Unitary into a set of Rz by angle phi and Givens Rotations by angle theta.
     Input:
-    U (np.array):
+    U (np.array): Rotation matrix
+    tol: tolerance for U elements
     '''
-    #filter small values
+    
     U[abs(U) < tol] = 0
     n = U.shape[0]
+
     theta = []
     phi = []
-    for c in range(n):
-        for r in range(n-1, c, -1):
+    if ordering is None:
+        for c in range(n):
+            for r in range(n-1, c, -1):
+                t = np.arctan2(-U[r,c], U[r-1,c])
+                theta.append((t, r, r-1))
+                
+                g = givens_matrix(n,r,r-1,t)
+                U = np.dot(g, U)
+    else:
+        for r, c in ordering:
             t = np.arctan2(-U[r,c], U[r-1,c])
-            theta.append([t, r, r-1])
+            theta.append((t, r, r-1))
+            
             g = givens_matrix(n,r,r-1,t)
             U = np.dot(g, U)
+    
     for i in range(n):
-        phi.append(np.angle(U[i,i]))
+        ph = np.angle(U[i,i])
+        phi.append((ph, i))
+        
     return theta, phi
 
 def givens_matrix(n, p, q, theta): #verified

tequila/grouping/fermionic_methods.py

@@ -214,12 +214,15 @@ def do_svd(h_ferm, n_elec):
     return all_uops, cartan_obt, cartan_tbts, meas_alloc
 
 
-def get_fermion_wise(H, U):
+def get_fermion_wise(H, U, qubit_list = []):
+    '''
+    Return z_form and orbital rotations over qubits at qubit_list
+    '''
 
     H = ferm.cartan_tbt_to_ferm(H, spin_orb = True)
     z_form = QubitHamiltonian(jordan_wigner(H))
 
-    circuit = ferm.get_orb_rot(U, tol = 1e-12)
+    circuit = ferm.get_orb_rot(U, qubit_list=qubit_list, tol = 1e-12)
     return [z_form, circuit]
 
 def get_init_ops(h_ferm, mol_name, calc_type, spin_orb, save=True):

tequila/hamiltonian/paulis.py

@@ -209,7 +209,7 @@ def Sm(qubit) -> QubitHamiltonian:
     Initialize
 
     .. math::
-        \\frac{1}{2} \\left( \\sigma_x + i \\sigma_y \\right)
+        \\frac{1}{2} \\left( \\sigma_x - i \\sigma_y \\right)
 
     Parameters
     ----------

tequila/optimizers/optimizer_gd.py

@@ -334,11 +334,12 @@ class OptimizerGD(Optimizer):
 
 
             if not self.silent:
+                self.__dx = numpy.asarray(self.__dx)
                 print("%3i   %+15.8f   %+7.2e   %7.3e   %7.3e    %s"
                       % (step,
                          e,
                          e-last,
-                         numpy.max(abs(self.__dx)),
+                         numpy.max([abs(x) for x in self.__dx]),
                          numpy.sqrt(numpy.average(self.__dx**2)),
                          comment))
 

tequila/quantumchemistry/orbital_optimizer.py

@@ -37,7 +37,7 @@ class OptimizeOrbitalsResult:
         self.iterations += 1
 
 def optimize_orbitals(molecule, circuit=None, vqe_solver=None, pyscf_arguments=None, silent=False,
-                      vqe_solver_arguments=None, initial_guess=None, return_mcscf=False, use_hcb=False, *args, **kwargs):
+                      vqe_solver_arguments=None, initial_guess=None, return_mcscf=False, use_hcb=False, molecule_factory=None, *args, **kwargs):
     """
 
     Parameters
@@ -97,9 +97,9 @@ def optimize_orbitals(molecule, circuit=None, vqe_solver=None, pyscf_arguments=N
         if n_qubits > n_orbitals:
             warnings.warn("Potential inconsistency in orbital optimization: use_hcb is switched on but we have\n n_qubits={} in the circuit\n n_orbital={} in the molecule\n".format(n_qubits,n_orbitals), TequilaWarning)
 
-    wrapper = PySCFVQEWrapper(molecule_arguments=pyscf_molecule.parameters, n_electrons=pyscf_molecule.n_electrons,
+    wrapper = PySCFVQEWrapper(molecule_arguments={"parameters":pyscf_molecule.parameters, "transformation":molecule.transformation}, n_electrons=pyscf_molecule.n_electrons,
                               const_part=c, circuit=circuit, vqe_solver_arguments=vqe_solver_arguments, silent=silent,
-                              vqe_solver=vqe_solver, *args, **kwargs)
+                              vqe_solver=vqe_solver, molecule_factory=molecule_factory, *args, **kwargs)
     mc.fcisolver = wrapper
     mc.internal_rotation = True
     if pyscf_arguments is not None:
@@ -153,7 +153,7 @@ class PySCFVQEWrapper:
 
     # needs initialization
     n_electrons: int = None
-    molecule_arguments: ParametersQC = None
+    molecule_arguments: dict = None
 
     # internal data
     rdm1: numpy.ndarray = None
@@ -168,6 +168,7 @@ class PySCFVQEWrapper:
     vqe_solver: typing.Callable = None
     circuit: QCircuit = None
     vqe_solver_arguments: dict = field(default_factory=dict)
+    molecule_factory: typing.Callable = None
 
     def reorder(self, M, ordering, to):
         # convenience since we need to reorder
@@ -183,9 +184,14 @@ class PySCFVQEWrapper:
         restrict_to_hcb = self.vqe_solver_arguments is not None and "restrict_to_hcb" in self.vqe_solver_arguments and \
                           self.vqe_solver_arguments["restrict_to_hcb"]
 
-        molecule = QuantumChemistryBase(one_body_integrals=h1, two_body_integrals=h2of,
+        if self.molecule_factory is None:
+            molecule = QuantumChemistryBase(one_body_integrals=h1, two_body_integrals=h2of,
                                         nuclear_repulsion=self.const_part, n_electrons=self.n_electrons,
-                                        parameters=self.molecule_arguments)
+                                        **self.molecule_arguments)
+        else:
+            molecule = self.molecule_factory(one_body_integrals=h1, two_body_integrals=h2of,
+                                        nuclear_repulsion=self.const_part, n_electrons=self.n_electrons,
+                                        **self.molecule_arguments)
         if restrict_to_hcb:
             H = molecule.make_hardcore_boson_hamiltonian()
         else:
@@ -214,7 +220,7 @@ class PySCFVQEWrapper:
         else:
             # static ansatz
             U = self.circuit
-            
+
         rdm1, rdm2 = molecule.compute_rdms(U=U, variables=result.variables, spin_free=True, get_rdm1=True, get_rdm2=True, use_hcb=restrict_to_hcb)
         rdm2 = self.reorder(rdm2, 'dirac', 'mulliken')
         if not self.silent:

tequila/quantumchemistry/pyscf_interface.py

@@ -1,11 +1,9 @@
-from tequila import TequilaException, TequilaWarning, ExpectationValue, QCircuit, minimize
-from openfermion import MolecularData
+from tequila import TequilaException
 from tequila.quantumchemistry.qc_base import QuantumChemistryBase
 from tequila.quantumchemistry import ParametersQC, NBodyTensor
-from dataclasses import dataclass, field
 import pyscf
 
-import numpy, typing, warnings
+import numpy, typing
 
 
 class OpenVQEEPySCFException(TequilaException):
@@ -48,7 +46,15 @@ class QuantumChemistryPySCF(QuantumChemistryBase):
             # solve restricted HF
             mf = pyscf.scf.RHF(mol)
             mf.kernel()
-            self.irreps = mf.get_irrep_nelec()
+
+            # only works if point_group is not C1
+            # otherwise PySCF uses a different SCF object
+            # irrep information is however not critical to tequila
+            if hasattr(mf, "get_irrep_nelec"):
+                self.irreps = mf.get_irrep_nelec()
+            else:
+                self.irreps = None
+                
             orbital_energies = mf.mo_energy
 
             # compute mo integrals
@@ -71,18 +77,6 @@ class QuantumChemistryPySCF(QuantumChemistryBase):
 
         super().__init__(parameters=parameters, transformation=transformation, *args, **kwargs)
 
-    @classmethod
-    def from_tequila(cls, molecule, transformation=None, *args, **kwargs):
-        c, h1, h2 = molecule.get_integrals()
-        if transformation is None:
-            transformation = molecule.transformation
-        return cls(nuclear_repulsion=c,
-                   one_body_integrals=h1,
-                   two_body_integrals=h2,
-                   n_electrons=molecule.n_electrons,
-                   transformation=transformation,
-                   parameters=molecule.parameters, *args, **kwargs)
-
     def compute_fci(self, *args, **kwargs):
         from pyscf import fci
         c, h1, h2 = self.get_integrals(ordering="chem")

tequila/quantumchemistry/qc_base.py

@@ -106,6 +106,19 @@ class QuantumChemistryBase:
         self._rdm1 = None
         self._rdm2 = None
 
+
+    @classmethod
+    def from_tequila(cls, molecule, transformation=None, *args, **kwargs):
+        c, h1, h2 = molecule.get_integrals()
+        if transformation is None:
+            transformation = molecule.transformation
+        return cls(nuclear_repulsion=c,
+                   one_body_integrals=h1,
+                   two_body_integrals=h2,
+                   n_electrons=molecule.n_electrons,
+                   transformation=transformation,
+                   parameters=molecule.parameters, *args, **kwargs)
+
     def supports_ucc(self):
         """
         check if the current molecule supports UCC operations
@@ -1089,7 +1102,8 @@ class QuantumChemistryBase:
                             assume_real: bool = True,
                             hcb_optimization: bool = None,
                             spin_adapt_singles: bool = True,
-                            neglect_z=False,
+                            neglect_z: bool = False,
+                            mix_sd: bool = False,
                             *args, **kwargs):
         """
         UpGCCSD Ansatz similar as described by Lee et. al.
@@ -1114,6 +1128,10 @@ class QuantumChemistryBase:
         assume_real
             assume a real wavefunction (that is always the case if the reference state is real)
             reduces potential gradient costs from 4 to 2
+        mix_sd
+            Changes the ordering from first all doubles and then all singles excitations (DDDDD....SSSS....) to
+            a mixed order (DS-DS-DS-DS-...) where one DS pair acts on the same MOs. Useful to consider when systems
+            with high electronic correlation and system high error associated with the no Trotterized UCC.
         Returns
         -------
             UpGCCSD ansatz
@@ -1154,7 +1172,8 @@ class QuantumChemistryBase:
                 raise Exception(
                     "name={}, Singles can't be realized without mapping back to the standard encoding leave S or HCB out of the name".format(
                         name))
-
+        if hcb_optimization and mix_sd:
+            raise TequilaException("Mixed SD can not be employed together with HCB Optimization")
         # convenience
         S = "S" in name.upper()
         D = "D" in name.upper()
@@ -1165,7 +1184,8 @@ class QuantumChemistryBase:
             if include_reference:
                 U = self.prepare_reference()
             U += self.make_upccgsd_layer(include_singles=S, include_doubles=D, indices=indices, assume_real=assume_real,
-                                         label=(label, 0), spin_adapt_singles=spin_adapt_singles, *args, **kwargs)
+                                         label=(label, 0), mix_sd=mix_sd, spin_adapt_singles=spin_adapt_singles, *args,
+                                         **kwargs)
         else:
             U = QCircuit()
             if include_reference:
@@ -1184,12 +1204,14 @@ class QuantumChemistryBase:
 
         for k in range(1, order):
             U += self.make_upccgsd_layer(include_singles=S, include_doubles=D, indices=indices, label=(label, k),
-                                         spin_adapt_singles=spin_adapt_singles, neglect_z=neglect_z)
+                                         spin_adapt_singles=spin_adapt_singles, neglect_z=neglect_z, mix_sd=mix_sd)
 
         return U
 
-    def make_upccgsd_layer(self, indices, include_singles=True, include_doubles=True, assume_real=True, label=None,
-                           spin_adapt_singles: bool = True, angle_transform=None, mix_sd=False, neglect_z=False, *args,
+    def make_upccgsd_layer(self, indices, include_singles: bool = True, include_doubles: bool = True,
+                           assume_real: bool = True, label=None,
+                           spin_adapt_singles: bool = True, angle_transform=None, mix_sd: bool = False,
+                           neglect_z: bool = False, *args,
                            **kwargs):
         U = QCircuit()
         for idx in indices:
@@ -1207,7 +1229,7 @@ class QuantumChemistryBase:
                                                    indices=((2 * idx[0], 2 * idx[1]), (2 * idx[0] + 1, 2 * idx[1] + 1)),
                                                    assume_real=assume_real, **kwargs)
             if include_singles and mix_sd:
-                U += self.make_upccgsd_singles(indices=[idx], assume_real=assume_real, label=label,
+                U += self.make_upccgsd_singles(indices=[(idx,)], assume_real=assume_real, label=label,
                                                spin_adapt_singles=spin_adapt_singles, angle_transform=angle_transform,
                                                neglect_z=neglect_z)
 

tequila/simulators/simulator_cirq.py

@@ -5,10 +5,12 @@ from tequila import BitString, BitNumbering
 import sympy
 from tequila.utils import to_float
 
+import importlib
 import numpy as np
 import typing, numbers
 
 import cirq
+import cirq_google
 
 map_1 = lambda x: {'exponent': x}
 map_2 = lambda x: {'exponent': x / np.pi, 'global_shift': -0.5}
@@ -356,35 +358,23 @@ class BackendCircuitCirq(BackendCircuit):
         line = None
         circuit = None
         if isinstance(device, cirq.Device):
-            if isinstance(device, cirq.google.devices.XmonDevice) or isinstance(device,
-                                                                                cirq.google.devices.serializable_device.SerializableDevice):
-                options = ['xmon', 'xmon_partial_cz', 'sqrt_iswap', 'sycamore']
-                if device in [cirq.google.Sycamore, cirq.google.Sycamore23]:
-                    options = ['sycamore', 'sqrt_iswap', 'xmon', 'xmon_partial_cz']
-                for option in options:
-                    try:
-                        line = cirq.google.line_on_device(device, length=len(self.abstract_circuit.qubits))
-
-                        circuit = cirq.google.optimized_for_sycamore(circuit=c, new_device=device,
-                                                                     optimizer_type=option,
-                                                                     qubit_map=lambda q: line[q.x])
-                    except:
-                        line = None
-                        pass
-                if circuit is None:
-                    raise TequilaCirqException('could not optimize for device={}'.format(device))
-
+            HAS_GOOGLE = importlib.util.find_spec('cirq_google')
+            assert HAS_GOOGLE, TequilaCirqException(' cirq_google package is not installed.')
+            
+            if device in [cirq_google.Sycamore, cirq_google.Sycamore23]:
+                try:
+                    circuit = cirq.optimize_for_target_gateset(circuit=c, gateset=cirq_google.SycamoreTargetGateset())
+                except ValueError as E:
+                    original_message = str(E)
+                    raise TequilaCirqException('original message:\n{}\n\ncould not optimize for device={}'.format(original_message,device))
             else:
                 ### under construction (potentially on other branches)
-                raise TequilaException('Only known and Xmon devices currently functional. Sorry!')
+                raise TequilaException('Only Sycamore and Sycamore23 devices currently functional. Sorry!')
+
         else:
             raise TequilaException(
                 'build_device_circuit demands a cirq.Device object; received {}, of type {}'.format(str(device),
                                                                                                     type(device)))
-
-        if line is not None:
-            for k in self.qubit_map.keys():
-                self.qubit_map[k].instance = line[self.qubit_map[k].instance.x]
         return circuit
 
     def build_noisy_circuit(self, noise):
@@ -447,7 +437,7 @@ class BackendCircuitCirq(BackendCircuit):
             the device on which to execute cirq circuits.
         """
         if isinstance(device, str):
-            return getattr(cirq.google, device)
+            return getattr(cirq_google, device)
         else:
             if device is None:
                 return device
@@ -474,7 +464,7 @@ class BackendCircuitCirq(BackendCircuit):
             return
         else:
             assert isinstance(device, str)
-            if device.lower() in ['foxtail', 'sycamore', 'sycamore23', 'bristlecone']:
+            if device.lower() in ['sycamore', 'sycamore23']:
                 pass
             else:
                 raise TequilaException('requested device {} could not be found!'.format(device))

tequila/version.py

@@ -1,2 +1,2 @@
-__version__ = "1.8.9"
-__author__ = "Jakob Kottmann and Sumner Alperin-Lea and Teresa Tamayo-Mendoza and Alba Cervera-Lierta and Cyrille Lavigne and Tzu-Ching Yen and Vladyslav Verteletskyi and Philipp Schleich and Abhinav Anand and Matthias Degroote and Skylar Chaney and Maha Kesibi and Naomi Grace Curnow and Brandon Solo and Georgios Tsilimigkounakis and Claudia Zendejas-Morales and Artur F Izmaylov and Alan Aspuru-Guzik ... "
+__version__ = "1.9.1"
+__author__ = "Tequila Developers "

{tequila_basic-1.8.9.dist-info → tequila_basic-1.9.1.dist-info}/METADATA

@@ -1,19 +1,19 @@
 Metadata-Version: 2.1
 Name: tequila-basic
-Version: 1.8.9
+Version: 1.9.1
 Summary: A High-Level Abstraction Framework for Quantum Algorithms
 Home-page: https://github.com/tequilahub/tequila
-Author: Jakob Kottmann and Sumner Alperin-Lea and Teresa Tamayo-Mendoza and Alba Cervera-Lierta and Cyrille Lavigne and Tzu-Ching Yen and Vladyslav Verteletskyi and Philipp Schleich and Abhinav Anand and Matthias Degroote and Skylar Chaney and Maha Kesibi and Naomi Grace Curnow and Brandon Solo and Georgios Tsilimigkounakis and Claudia Zendejas-Morales and Artur F Izmaylov and Alan Aspuru-Guzik ... 
+Author: Tequila Developers 
 Author-email: jakob.kottmann@gmail.com
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
-Requires-Dist: scipy (<1.11)
+Requires-Dist: scipy <1.11
 Requires-Dist: sympy
 Requires-Dist: autograd
 Requires-Dist: setuptools
 Requires-Dist: pytest
-Requires-Dist: openfermion (~=1.0)
+Requires-Dist: openfermion ~=1.0
 Requires-Dist: dataclasses ; python_version < "3.7"
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-lightgrey.svg)](LICENCE) [![DOI](https://zenodo.org/badge/259718912.svg)](https://zenodo.org/badge/latestdoi/259718912) [![PyPI version](https://badge.fury.io/py/tequila-basic.svg)](https://badge.fury.io/py/tequila-basic) ![CI](https://github.com/tequilahub/tequila/actions/workflows/ci_basic.yml/badge.svg)
@@ -33,7 +33,7 @@ Tequila can execute the underlying quantum expectation values on state of the ar
 
 # Installation
 Recommended Python version is 3.8-3.9.   
-Tequila supports linux, osx and windows. However, not all optional dependencies are supported on windows.
+Tequila supports linux, osx and windows. However, not all optional dependencies are supported on windows.  
 
 ## Install from PyPi
 **Do not** install like this: (Minecraft lovers excluded)
@@ -246,6 +246,17 @@ K. Gratsea, C. Sun, P.D. Johnson
 When to Reject a Ground State Preparation Algorithm  
 [arxiv:2212.09492](https://doi.org/10.48550/arXiv.2212.09492)  
 
+R.P. Pothukuchi, L. Lufkin, Y.J. Shen, A. Simon, R. Thorstenson, B.E. Trevisan, M. Tu, M. Yang, B. Foxman, V. S. Pothukuchi, G. Epping, B. J. Jongkees, T.-H. Kyaw, J. R. Busemeyer, J. D Cohen, A. Bhattacharjee  
+Quantum Cognitive Modeling: New Applications and Systems Research Directions  
+[arxiv:2309.00597](https://arxiv.org/abs/2309.00597)  
+
+T.-H. Kyaw, M. B. Soley, B. Allen, P. Bergold, C. Sun, V.S. Batista and A. Aspuru-Guzik  
+Boosting quantum amplitude exponentially in variational quantum algorithms  
+[10.1088/2058-9565/acf4ba](doi.org/10.1088/2058-9565/acf4ba)  
+
+A.G. Cadavid, I. Montalban, A. Dalal, E. Solano, N.N. Hegade  
+Efficient DCQO Algorithm within the Impulse Regime for Portfolio Optimization  
+[arxiv:2308.15475](https://arxiv.org/abs/2308.15475)  
 
 Let us know, if you want your research project and/or tutorial to be included in this list!
 

{tequila_basic-1.8.9.dist-info → tequila_basic-1.9.1.dist-info}/RECORD

@@ -1,6 +1,6 @@
 tequila/__init__.py,sha256=FV8-j7GEw_VYadsZUp3M2mGRQxVUYYG3W1jiI6in3CY,1959
 tequila/autograd_imports.py,sha256=t7V5uYaI0GzjD7pSjkYtiaj3BzSvkm_RL2KcYfNwNhM,1529
-tequila/version.py,sha256=5wyIkBlSaqouz7lT4mnIs9ich9QzHwrTD74CS6IzvOQ,432
+tequila/version.py,sha256=OQns-ZLbw14JA1biX794LPwT3m5kGViyNFrR4FKkTfU,57
 tequila/apps/__init__.py,sha256=GJb04napv8AAx5EHxS5C1CMv9kxQeu7aA-ZMWk6X_eQ,1623
 tequila/apps/_unary_state_prep_impl.py,sha256=SzRtI0Nx29ODygvYYdC1NnSTCL70wY7NTAvqhiwpMDs,21757
 tequila/apps/unary_state_prep.py,sha256=QCrD9Ty2RkXc1Mh_MitFPIdaPs_fLxp_dtWVBZi0tSE,9403
@@ -12,10 +12,10 @@ tequila/apps/robustness/__init__.py,sha256=6BOjqcFWP3ymuit4JJ5cbzxS-G2AOCTdwcl87
 tequila/apps/robustness/helpers.py,sha256=t8VgwMfgrhVaa0sNYaxfCIHsEQXL4WAEaT-UJGJkFyE,2721
 tequila/apps/robustness/interval.py,sha256=m3D1wBRTLRpGQdnabzcDrlxWqN0uCf80NG-enbZrcoY,24735
 tequila/circuit/__init__.py,sha256=ZgoUEjU_NggxjKYkJjh5aO-6VdUjnO5CLxKB44rHzQc,301
-tequila/circuit/_gates_impl.py,sha256=-o7Hf3tVskAP9CbyGGYtwDGaf5OrCBn-uXF2RZ2_ZmA,16408
+tequila/circuit/_gates_impl.py,sha256=iB40Sg9l9UoCCayu0l4vGjgvEHUVVbXMaGdUtXIHa1w,17821
 tequila/circuit/circuit.py,sha256=u1qwDFNrZspgea4BFcxwG-hk43ZKAtO2GVCchuctu4s,32044
 tequila/circuit/compiler.py,sha256=fsHnnNZo43VWUl_n34P21b4GAi7k2kwoYdx0xlbAuZY,32685
-tequila/circuit/gates.py,sha256=8xXTIUUiH5DnabnKXuPagKHajKbSQLfqHolikGKIy9o,35355
+tequila/circuit/gates.py,sha256=pOvX9_vACFyUAZRG4EGW3_aZGXysUJwUV8oFiKyLJ50,35906
 tequila/circuit/gradient.py,sha256=Y4dNL6nkZUEkKJvaA3hxaSEa8_b_3XZwxy3j8tGsOmA,10465
 tequila/circuit/noise.py,sha256=2LJ7Xq5f78x9p4imIz76l_lABQZwgNteNBFkWmUAQvo,8322
 tequila/circuit/pyzx.py,sha256=XHhKoklhEcbpYkgkWHBLmKF-vyt_Oz-pX-Ctvd4nAOQ,1472
@@ -26,11 +26,11 @@ tequila/grouping/binary_rep.py,sha256=VVM2o6B_RC0uH8kqE4yNxTzkGlgUm-CJTZ6z5J7R9I
 tequila/grouping/binary_utils.py,sha256=ubV8zv3nmz2o74A2W69LeCH6bIZZLHw48lk8ROv-jas,10916
 tequila/grouping/compile_groups.py,sha256=a9it48zZxJs167nz1FWS_oEmPHPuXq0oLaCs1hJgyBE,66415
 tequila/grouping/ev_utils.py,sha256=4pnzjRYyOB4KTZsfhs7YSU8Ez4jCJP3YSFKtMOjSwgY,8968
-tequila/grouping/fermionic_functions.py,sha256=bWDuEYz7atURv5dPHOcufBxXHGNxWRFIl5yQ-Jam-yM,32412
-tequila/grouping/fermionic_methods.py,sha256=iDOuR4qHtk8L6BaXex7v1Y_wrIDGmt9gkqsgwjpm6gY,27685
+tequila/grouping/fermionic_functions.py,sha256=v9R9L43t3CNQlIo-k3uTk2nlP69TyVyyFKSHu0bxiNg,34109
+tequila/grouping/fermionic_methods.py,sha256=-vzRE5wLw49tTLPP0EUAKq-di6BTT2bc1EwA7tdnBns,27807
 tequila/grouping/overlapping_methods.py,sha256=A8oVXInkZxqrBh_SoOcUwdAca6dbiF5O4YheQFAaU1s,11059
 tequila/hamiltonian/__init__.py,sha256=X7edib1ejUf01hb8Jk5IHYnAP51WoN0UAhg4yLRicFI,119
-tequila/hamiltonian/paulis.py,sha256=2kzSq0yvA20UmJqDHnHqX9fsbhA7T70P_mR4QuSiv60,9037
+tequila/hamiltonian/paulis.py,sha256=a_tOS4PU3_uNHyc4nH4LwvKhC3vQ7Yan7LTiIoGkC-I,9037
 tequila/hamiltonian/paulistring.py,sha256=zX3G6nljdYeQnhHsOAG0Pwx-7CJVMOc6SPV8d5ZYK1U,351
 tequila/hamiltonian/qubit_hamiltonian.py,sha256=jPEZ0FxVVHNKou2iS4cZK0ysByOZSbY-VZ6XFLxTakg,21391
 tequila/ml/__init__.py,sha256=ojCJTssfvNxw2aFnXf7IWaOL8XigFxDZihFPZrVfjcg,120
@@ -44,7 +44,7 @@ tequila/objective/qtensor.py,sha256=eSjFOEVW-kLoM8jn1RD2_E_kHVAm579Ji3_lMcJg7cE,
 tequila/optimizers/__init__.py,sha256=sSyXc_FD0wTzS0cmgkdf1DhH-0XMUp2k5wARMM57nhI,5603
 tequila/optimizers/_containers.py,sha256=CXbWWQory_aADxlaMw4deIr03K_el-0E12GmpA0vX10,7161
 tequila/optimizers/optimizer_base.py,sha256=Nc1HwlgfeB6XifoaWdFVLhdyHfeqQuhLvOtmtoFDMPY,32272
-tequila/optimizers/optimizer_gd.py,sha256=KCwU2MjfotTMZPahhcAc7RuIICgMtImJEX7uai1Nmjs,38993
+tequila/optimizers/optimizer_gd.py,sha256=QF84K2XDn_-0w9htDlEpIaaGGtfudNamIvVCgx1JkuE,39059
 tequila/optimizers/optimizer_gpyopt.py,sha256=ZDiln0khwc5PHTBuX83eRkclSKIt-iFVYaTK8A1ZX9w,11313
 tequila/optimizers/optimizer_phoenics.py,sha256=31GBSC4P_-JqjYn3Bjmn3W7vDXW3Zn8aRxi8FWh2Uqc,13448
 tequila/optimizers/optimizer_scipy.py,sha256=zqRVQ-Whr74KCGP7Zg1jQkl9S3j9s1kS4oCrCtX30gY,18949
@@ -52,14 +52,14 @@ tequila/quantumchemistry/__init__.py,sha256=7P3LAgRt9BYHFlByOx0u_lkYuUykqMXPFnic
 tequila/quantumchemistry/chemistry_tools.py,sha256=zQ9CX3qXhkGvSpdsZGHzdwnzCBP-PhY06M0FyOXJedc,40939
 tequila/quantumchemistry/encodings.py,sha256=y9h6rjq1K9IPVBMbRFQWXyBuAIZzgh2DVw2IUKtpuIM,8656
 tequila/quantumchemistry/madness_interface.py,sha256=WbBnbVInjoA_2xtp7ejifj2I1L7ZHtxK5ToOEwMD2BY,36254
-tequila/quantumchemistry/orbital_optimizer.py,sha256=zKSAZB8FU7E_dTgLb5wg_FgpUzZSafruJB_iuTvcoWI,11289
+tequila/quantumchemistry/orbital_optimizer.py,sha256=dmwj9cm0wj6W6oSvhO-JTNJVF6EQH5onF4JOkvsncL0,11745
 tequila/quantumchemistry/psi4_interface.py,sha256=syNaDvlSmCsyB4f7idn3VGbMKyKo83vJHD5y5LpHwaM,29953
-tequila/quantumchemistry/pyscf_interface.py,sha256=MHBxbUI6-4L0BpEB5ljaf2rg_Pox4DBxePj6VqIFZ9Y,6362
-tequila/quantumchemistry/qc_base.py,sha256=MRWlaFHs-T9QHvpLrQ7wvIvdvwxKGoMaTNcNg1lQMT4,91623
+tequila/quantumchemistry/pyscf_interface.py,sha256=hOHtT8ONiNAc0MNNnztE2tVq1OHMxobUsniRYuZh9sQ,5995
+tequila/quantumchemistry/qc_base.py,sha256=oze8z7LyP0gvJcwMZzPjuEfa3neOfbzBF2m7O_ds6WA,92858
 tequila/simulators/__init__.py,sha256=VFw4sJIt4Zc0-__eYnksN8Ku9qMhbPpHJEkXMWUiD30,4
 tequila/simulators/simulator_api.py,sha256=mLYA6GzujaNAGrDq1rtLQrW8tFZsCeyYnOnWRTlU6Eo,24172
 tequila/simulators/simulator_base.py,sha256=93d-f4fNkJ2CtpL9OpgKcypmZH96Mdd9ESdZYn9jH48,33174
-tequila/simulators/simulator_cirq.py,sha256=fJ3_E05yBfbzzZbv0Ry4UyAus1dwLs8TsLI5u6GMLsA,17220
+tequila/simulators/simulator_cirq.py,sha256=z8G3dtZluaQZWPaNs4o3SBKfC33GClC-nplVOyhI1sg,16535
 tequila/simulators/simulator_pyquil.py,sha256=Xm8fDg9PTFOg3apzd0T8hNKHy4sFrJIbSdnLtvtm-HM,24240
 tequila/simulators/simulator_qibo.py,sha256=evOGd_-uyUQaQu60K02KIIqtTqjn1jW6XS9ux2TsC9M,25095
 tequila/simulators/simulator_qiskit.py,sha256=KZhyvbziCEOx-oO5bfyZlU0cEBkZNW1uvuHLPkVNrJo,23429
@@ -79,8 +79,8 @@ tequila/utils/keymap.py,sha256=RgQzeHEfRVee0-uoH-QsLYsGsXyMhEp3n33KCH-EV2k,3735
 tequila/utils/misc.py,sha256=e62ASkFReaLJQXnBXzyYukzXZnXNoURsM1luoMeIXiE,919
 tequila/wavefunction/__init__.py,sha256=q4DVL0lGFg03PogRMYA6S8MQqqmLYQiU9VNOF-YQxfQ,50
 tequila/wavefunction/qubit_wavefunction.py,sha256=16Y9vRj6Yc6sBAKRUHVXJG4lJLDjWyN1b5fugf2LAmI,11881
-tequila_basic-1.8.9.dist-info/LICENSE,sha256=oG1FtUav5_xrym9ByiG5emJDQRcbnAfTB08fRV9TCiE,1114
-tequila_basic-1.8.9.dist-info/METADATA,sha256=064avSN56yx97TNuHvb2672OvFknkzZ1k2vmPAkiJxM,18894
-tequila_basic-1.8.9.dist-info/WHEEL,sha256=AtBG6SXL3KF_v0NxLf0ehyVOh0cold-JbJYXNGorC6Q,92
-tequila_basic-1.8.9.dist-info/top_level.txt,sha256=VBH0gl6mDMbcLHKlO0yEAqtcq08DqBHz4gRJ9jafl5w,8
-tequila_basic-1.8.9.dist-info/RECORD,,
+tequila_basic-1.9.1.dist-info/LICENSE,sha256=oG1FtUav5_xrym9ByiG5emJDQRcbnAfTB08fRV9TCiE,1114
+tequila_basic-1.9.1.dist-info/METADATA,sha256=T_Um6-6ZQ9139PZ718W89V3XSY4tMdDv3mqaw--X730,19293
+tequila_basic-1.9.1.dist-info/WHEEL,sha256=Xo9-1PvkuimrydujYJAjF7pCkriuXBpUPEjma1nZyJ0,92
+tequila_basic-1.9.1.dist-info/top_level.txt,sha256=VBH0gl6mDMbcLHKlO0yEAqtcq08DqBHz4gRJ9jafl5w,8
+tequila_basic-1.9.1.dist-info/RECORD,,

{tequila_basic-1.8.9.dist-info → tequila_basic-1.9.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.0)
+Generator: bdist_wheel (0.41.3)
 Root-Is-Purelib: true
 Tag: py3-none-any