tequila-basic 1.8.9__tar.gz → 1.9.1__tar.gz

{tequila-basic-1.8.9 → tequila-basic-1.9.1}/PKG-INFO

@@ -1,12 +1,20 @@
 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: sympy
+Requires-Dist: autograd
+Requires-Dist: setuptools
+Requires-Dist: pytest
+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)
 
@@ -25,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)
@@ -238,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/src/tequila_basic.egg-info/PKG-INFO → tequila-basic-1.9.1/README.md

@@ -1,13 +1,3 @@
-Metadata-Version: 2.1
-Name: tequila-basic
-Version: 1.8.9
-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-email: jakob.kottmann@gmail.com
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
 [![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)
 
 # Tequila
@@ -25,7 +15,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)
@@ -238,6 +228,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 → tequila-basic-1.9.1}/requirements.txt

@@ -13,6 +13,7 @@ openfermion ~= 1.0 # can not be smaller than 1.0
 
 #optional quantum backends
 #cirq >= 0.9.2 #
+#cirq_google
 #qiskit>=0.30
 #pyquil<3.0 # you also need to install the forest-sdk
 ##qulacs-gpu # you can't have #qulacs and #qulacs-gpu at the same time

{tequila-basic-1.8.9 → tequila-basic-1.9.1}/src/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-basic-1.8.9 → tequila-basic-1.9.1}/src/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-basic-1.8.9 → tequila-basic-1.9.1}/src/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-basic-1.8.9 → tequila-basic-1.9.1}/src/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-basic-1.8.9 → tequila-basic-1.9.1}/src/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-basic-1.8.9 → tequila-basic-1.9.1}/src/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))