tequila-basic 1.9.8__py3-none-any.whl → 1.9.10__py3-none-any.whl

tequila/apps/unary_state_prep.py

@@ -8,7 +8,9 @@ The whole thing is currently not very stable
 
 from tequila.circuit import QCircuit
 from tequila import BitString
-import typing, numpy, copy
+import typing
+import numpy
+import copy
 from tequila import TequilaException
 from tequila.apps._unary_state_prep_impl import UnaryStatePrepImpl, sympy
 from tequila.simulators.simulator_symbolic import BackendCircuitSymbolic
@@ -26,8 +28,8 @@ class TequilaUnaryStateException(TequilaException):
 
     pass
 
-class UnaryStatePrep:
 
+class UnaryStatePrep:
     @property
     def n_qubits(self) -> int:
         return self._n_qubits
@@ -40,8 +42,9 @@ class UnaryStatePrep:
     def circuit(self) -> QCircuit:
         return self._abstract_circuit
 
-    def __init__(self, target_space: typing.List[BitString], max_repeat: int = 100,
-                 use_symbolic_solution: bool = False):
+    def __init__(
+        self, target_space: typing.List[BitString], max_repeat: int = 100, use_symbolic_solution: bool = False
+    ):
         """
         :param target_space: Give the target space by its basis functions
         e.g. target_space = ['00', '11']
@@ -70,7 +73,7 @@ class UnaryStatePrep:
         count = 0
         success = False
 
-        while (not success and count < self.max_repeat):
+        while not success and count < self.max_repeat:
             try:
                 count += 1
                 IMPL = UnaryStatePrepImpl()
@@ -81,13 +84,13 @@ class UnaryStatePrep:
             except NotImplementedError:
                 numpy.random.shuffle(target_space)
 
-        if not success: raise TequilaUnaryStateException(
-            "Could not disentangle the given state after " + str(count) + " restarts")
+        if not success:
+            raise TequilaUnaryStateException("Could not disentangle the given state after " + str(count) + " restarts")
 
         # get the equations to determine the angles
         simulator = BackendCircuitSymbolic(abstract_circuit=self._abstract_circuit, variables={})
         simulator.convert_to_numpy = False
-        variables = None # {k:k.name.evalf() for k in self._abstract_circuit.extract_variables()}
+        variables = None  # {k:k.name.evalf() for k in self._abstract_circuit.extract_variables()}
         wfn = simulator.simulate(initial_state=BitString.from_int(0, nbits=self.n_qubits), variables=variables)
         equations = []
         for k in target_space:
@@ -95,11 +98,11 @@ class UnaryStatePrep:
 
         normeq = -sympy.Integer(1)
         for c in abstract_coefficients.values():
-            normeq += c ** 2
+            normeq += c**2
         equations.append(normeq)
 
         # this gives back multiple solutions and some of them sometimes have sign errors ...
-        if (self._use_symbolic_solver):
+        if self._use_symbolic_solver:
             solutions = sympy.solve(equations, *tuple(abstract_angles), check=True, dict=True)[1]
             if len(abstract_angles) != len(solutions):
                 raise TequilaUnaryStateException("Could definetely not solve for the angles in UnaryStatePrep!")
@@ -137,7 +140,7 @@ class UnaryStatePrep:
                 raise TequilaException("UnaryStatePrep currently only possible for real coefficients")
             subs[ac] = sympy.Float(float(coeff.real))
         result = dict()
-        if (self._use_symbolic_solver):
+        if self._use_symbolic_solver:
             # fails a lot of times
             # better don't use
             # get the angle variables from the symbolic equations for the angles
@@ -148,7 +151,7 @@ class UnaryStatePrep:
             # integrated repeat loop for the case that the randomly generated guess is especially bad
             count = 0
             solutions = []
-            while (count < self.max_repeat and len(solutions) == 0):
+            while count < self.max_repeat and len(solutions) == 0:
                 try:
                     # same substitution map as before, but initialized as list of tuples
                     subsx = [x for x in subs.items()]
@@ -156,10 +159,10 @@ class UnaryStatePrep:
                     guess = numpy.random.uniform(0.1, 0.9 * 2 * numpy.pi, len(self._abstract_angles))
                     solutions = sympy.nsolve(equations, self._abstract_angles, guess)
                     count += 1
-                except:
+                except Exception:
                     count += 1
 
-            if (len(solutions) == 0):
+            if len(solutions) == 0:
                 raise TequilaUnaryStateException("Failed to numerically solve for angles")
 
             for i, symbol in enumerate(self._abstract_angles):
@@ -176,14 +179,15 @@ class UnaryStatePrep:
             assert wfn.length() == len(self._target_space)
             for key in wfn.keys():
                 try:
-                    assert (key in self._target_space)
+                    assert key in self._target_space
                 except AssertionError:
                     print("key=", key.binary, " not found in target space")
         except AssertionError:
-            raise TequilaException("UnaryStatePrep was not initialized for the basis states in your wavefunction\n"
-                                   "You gave:\n" + str(wfn) + "\n"
-                                                              "But the target_space is " + str(
-                [k.binary for k in self._target_space]) + "\n")
+            raise TequilaException(
+                "UnaryStatePrep was not initialized for the basis states in your wavefunction\n"
+                "You gave:\n" + str(wfn) + "\n"
+                "But the target_space is " + str([k.binary for k in self._target_space]) + "\n"
+            )
 
         angles = self._evaluate_angles(wfn=wfn)
 
@@ -194,7 +198,9 @@ class UnaryStatePrep:
             if hasattr(g, "parameter"):
                 symbol = g.parameter
                 # the module needs repairing ....
-                g2._parameter = assign_variable(-angles[-symbol()])  # the minus follows mahas convention since the circuits are daggered in the end
+                g2._parameter = assign_variable(
+                    -angles[-symbol()]
+                )  # the minus follows mahas convention since the circuits are daggered in the end
             result += g2
 
         return result
@@ -208,7 +214,7 @@ class UnaryStatePrep:
             g2 = copy.deepcopy(g)
             if hasattr(g, "parameter"):
                 symbol = g.parameter
-                name = str(-symbol) # kill the minus from the dagger
+                name = str(-symbol)  # kill the minus from the dagger
                 g2._parameter = assign_variable(name)
             result += g2
 
@@ -216,5 +222,5 @@ class UnaryStatePrep:
 
     def angles(self, wfn: QubitWaveFunction) -> typing.Dict[typing.Hashable, float]:
         sympy_angles = self._evaluate_angles(wfn=wfn)
-        angles = {assign_variable(str(key)):value for key, value in sympy_angles.items()}
-        return angles
+        angles = {assign_variable(str(key)): value for key, value in sympy_angles.items()}
+        return angles

tequila/autograd_imports.py

@@ -6,9 +6,10 @@ __AUTOGRAD__BACKEND__ = None
 try:
     import jax
     from jax import numpy
-    jax.config.update('jax_platform_name', 'cpu')
+
+    jax.config.update("jax_platform_name", "cpu")
     __AUTOGRAD__BACKEND__ = "jax"
-except:
+except Exception:
     # will pick autograd if jax is not installed
     # or if there are errors on import (like on M2 chips or when jax/jaxlib are not matching
     try:
@@ -19,18 +20,19 @@ except:
     except ImportError:
         raise TequilaException("Neither jax nor autograd found on your system")
 
-def change_classical_differentiation_backend(name:str):
+
+def change_classical_differentiation_backend(name: str):
     if name.lower() == "jax":
         try:
             import jax
             from jax import numpy
-        except:
+        except Exception:
             raise TequilaException("failed to load jax as classical differentiation backend")
     elif name.lower() == "autograd":
         try:
             import autograd as jax
             from autograd import numpy
-        except:
+        except Exception:
             raise TequilaException("failed to load autograd as classical differentiation backend")
 
     else:
@@ -38,6 +40,7 @@ def change_classical_differentiation_backend(name:str):
 
     return True
 
+
 def status():
     print("currently loaded autodiff numpy: {}, {}".format(numpy.__name__, numpy))
     print("currently loaded autodiff library: {}, {}".format(jax.__name__, jax))

tequila/circuit/__init__.py

@@ -3,7 +3,8 @@ from .noise import NoiseModel
 from .qpic import export_to
 from .compiler import CircuitCompiler as CircuitCompiler
 
+
 def compile_circuit(U, *args, **kwargs):
     # see CircuitCompiler documentation
     c = CircuitCompiler.standard_gate_set(*args, **kwargs)
-    return c(U)
+    return c(U)

tequila/circuit/_gates_impl.py

@@ -16,7 +16,7 @@ UnionParam = typing.Union[Variable, FixedVariable]
 
 
 class QGateImpl:
-    """"
+    """ "
     BaseClass for internal gate representation
     All other gate classes should derive from here
     """
@@ -47,12 +47,12 @@ class QGateImpl:
         return self.compute_max_qubit()
 
     def extract_variables(self):
-        if self.is_parametrized() and hasattr(self.parameter, "extract_variables"):
+        if self.is_parameterized() and hasattr(self.parameter, "extract_variables"):
             return self.parameter.extract_variables()
         else:
             return []
 
-    def is_parametrized(self) -> bool:
+    def is_parameterized(self) -> bool:
         return hasattr(self, "parameter")
 
     def make_generator(self, include_controls=False):
@@ -62,9 +62,8 @@ class QGateImpl:
         return self.generator
 
     def map_variables(self, variables):
-
-        if self.is_parametrized():
-            self.parameter=self.parameter.map_variables(variables)
+        if self.is_parameterized():
+            self.parameter = self.parameter.map_variables(variables)
 
         return self
 
@@ -82,7 +81,7 @@ class QGateImpl:
         """
         :return: return the hermitian conjugate of the gate.
         """
-        result=copy.deepcopy(self)
+        result = copy.deepcopy(self)
         result.generator *= -1.0
         return result
 
@@ -103,22 +102,25 @@ class QGateImpl:
         return (not self.control) and (len(self.target) == 1)
 
     def finalize(self):
-        if not self.target:
-            raise Exception('Received no targets upon initialization')
+        if not self.target and not isinstance(self, GlobalPhaseGateImpl):
+            raise Exception("Received no targets upon initialization")
         if self.is_controlled():
             for c in self.target:
                 if c in self.control:
                     raise Exception("control and target are the same qubit: " + self.__str__())
-        if hasattr(self,"generator") and self.generator:
+        if hasattr(self, "generator") and self.generator:
             if set(list(self.generator.qubits)) != set(list(self.target)):
-                raise Exception("qubits of generator and targets don't agree -- mapping error?\n gate = {}".format(self.__str__()))
+                raise Exception(
+                    "qubits of generator and targets don't agree -- mapping error?\n gate = {}".format(self.__str__())
+                )
         if hasattr(self, "generators"):
             genq = []
             for generator in self.generators:
                 genq += generator.qubits
             if set(list(genq)) != set(list(self.target)):
-                raise Exception("qubits of generator and targets don't agree -- mapping error?\n gate = {}".format(self.__str__()))
-
+                raise Exception(
+                    "qubits of generator and targets don't agree -- mapping error?\n gate = {}".format(self.__str__())
+                )
 
     def __str__(self):
         result = str(self.name) + "(target=" + str(self.target)
@@ -138,9 +140,9 @@ class QGateImpl:
         :return: highest qubit index used by this gate
         """
         if self.control is None:
-            return max(self.target)
+            return max(self.target, default=0)
         else:
-            return max(self.target + self.control)
+            return max(self.target + self.control, default=0)
 
     def __eq__(self, other):
         if self.name != other.name:
@@ -165,10 +167,11 @@ class QGateImpl:
             mapped.generator = self.generator.map_qubits(qubit_map=qubit_map)
         return mapped
 
+
 class ParametrizedGateImpl(QGateImpl, ABC):
-    '''
+    """
     the base class from which all parametrized gates inherit. User defined gates, when implemented, are liable to be members of this class directly.
-    '''
+    """
 
     @property
     def parameter(self):
@@ -178,12 +181,24 @@ class ParametrizedGateImpl(QGateImpl, ABC):
     def parameter(self, other):
         self._parameter = assign_variable(variable=other)
 
-    def __init__(self, name, parameter: UnionParam, target: UnionList, control: UnionList = None,
-                generator: QubitHamiltonian = None):
+    def __init__(
+        self,
+        name,
+        parameter: UnionParam,
+        target: UnionList,
+        control: UnionList = None,
+        generator: QubitHamiltonian = None,
+    ):
         # failsafe
-        if hasattr(parameter, "shape") and parameter.shape not in [tuple()]: # take care of new numpy conventions where scalars have shape ()
-            self._parameter=None
-            raise TequilaException("parameter has to be a scalar. Received {}\n{}\n{}".format(repr(parameter), type(parameter), str(parameter)))
+        if hasattr(parameter, "shape") and parameter.shape not in [
+            tuple()
+        ]:  # take care of new numpy conventions where scalars have shape ()
+            self._parameter = None
+            raise TequilaException(
+                "parameter has to be a scalar. Received {}\n{}\n{}".format(
+                    repr(parameter), type(parameter), str(parameter)
+                )
+            )
         self._parameter = assign_variable(variable=parameter)
         super().__init__(name=name, target=target, control=control, generator=generator)
 
@@ -209,16 +224,16 @@ class ParametrizedGateImpl(QGateImpl, ABC):
         result._parameter = assign_variable(-self.parameter)
         return result
 
-class DifferentiableGateImpl(ParametrizedGateImpl):
 
+class DifferentiableGateImpl(ParametrizedGateImpl):
     @property
     def eigenvalues_magnitude(self):
         return self._eigenvalues_magnitude
 
-    def __init__(self,eigenvalues_magnitude=None, assume_real=False, *args, **kwargs):
-        self._eigenvalues_magnitude=eigenvalues_magnitude
+    def __init__(self, eigenvalues_magnitude=None, assume_real=False, *args, **kwargs):
+        self._eigenvalues_magnitude = eigenvalues_magnitude
         super().__init__(*args, **kwargs)
-        self.assume_real=assume_real
+        self.assume_real = assume_real
 
     def shifted_gates(self, r=None):
         """
@@ -234,12 +249,12 @@ class DifferentiableGateImpl(ParametrizedGateImpl):
         if r is None:
             r = self.eigenvalues_magnitude
 
-        s =  np.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 = (np.sqrt(2) + 1)/np.sqrt(8) * r
-            coeff2 = (np.sqrt(2) - 1)/np.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):
@@ -257,16 +272,17 @@ class DifferentiableGateImpl(ParametrizedGateImpl):
 
         if self.is_controlled():
             # following https://doi.org/10.1039/D0SC06627C
-            p0 = paulis.Qp(self.control) # Qp = |0><0|
-            right2 = GeneralizedRotationImpl(angle=s, generator=p0, eigenvalues_magnitude=r/2)  # controls are in p0
-            left2 = GeneralizedRotationImpl(angle=-s, generator=p0, eigenvalues_magnitude=r/2)  # controls are in p0
-            return [(r, [right, right2]), (-r, [left , left2])]
+            p0 = paulis.Qp(self.control)  # Qp = |0><0|
+            right2 = GeneralizedRotationImpl(angle=s, generator=p0, eigenvalues_magnitude=r / 2)  # controls are in p0
+            left2 = GeneralizedRotationImpl(angle=-s, generator=p0, eigenvalues_magnitude=r / 2)  # controls are in p0
+            return [(r, [right, right2]), (-r, [left, left2])]
         else:
-            return [ (r, right), (-r, left) ]
+            return [(r, right), (-r, left)]
 
     def finalize(self):
         super().finalize()
 
+
 class RotationGateImpl(DifferentiableGateImpl):
     axis_to_string = {0: "x", 1: "y", 2: "z"}
     string_to_axis = {"x": 0, "y": 1, "z": 2}
@@ -294,8 +310,15 @@ class RotationGateImpl(DifferentiableGateImpl):
         return result
 
     def __init__(self, axis, angle, target: list, control: list = None, assume_real=False):
-        assert (angle is not None)
-        super().__init__(eigenvalues_magnitude=0.5, assume_real=assume_real, name=self.get_name(axis=axis), parameter=angle, target=target, control=control)
+        assert angle is not None
+        super().__init__(
+            eigenvalues_magnitude=0.5,
+            assume_real=assume_real,
+            name=self.get_name(axis=axis),
+            parameter=angle,
+            target=target,
+            control=control,
+        )
         self._axis = self.assign_axis(axis)
         self.generator = self.assign_generator(self.axis, self.target)
 
@@ -306,7 +329,7 @@ class RotationGateImpl(DifferentiableGateImpl):
         elif hasattr(axis, "lower") and axis.lower() in RotationGateImpl.string_to_axis:
             return RotationGateImpl.string_to_axis[axis.lower()]
         else:
-            assert (axis in [0, 1, 2])
+            assert axis in [0, 1, 2]
             return axis
 
     @staticmethod
@@ -319,11 +342,21 @@ class RotationGateImpl(DifferentiableGateImpl):
         return sum(paulis.Z(q) for q in qubits)
 
 
-class PhaseGateImpl(DifferentiableGateImpl):
+class GlobalPhaseGateImpl(DifferentiableGateImpl):
+    def __init__(self, phase):
+        super().__init__(
+            name="GlobalPhase",
+            parameter=phase,
+            target=(),  # Global phases don't act on any particular qubit
+            generator=paulis.I(),
+            eigenvalues_magnitude=0.5,
+        )
+
 
+class PhaseGateImpl(DifferentiableGateImpl):
     def __init__(self, phase, target: list, control: list = None):
-        assert (phase is not None)
-        super().__init__(eigenvalues_magnitude=0.5, name='Phase', parameter=phase, target=target, control=control)
+        assert phase is not None
+        super().__init__(eigenvalues_magnitude=0.5, name="Phase", parameter=phase, target=target, control=control)
         self.generator = paulis.Z(target) - paulis.I(target)
 
     def __pow__(self, power, modulo=None):
@@ -331,6 +364,7 @@ class PhaseGateImpl(DifferentiableGateImpl):
         result.parameter *= power
         return result
 
+
 class PowerGateImpl(ParametrizedGateImpl):
     """
     Attributes
@@ -344,9 +378,9 @@ class PowerGateImpl(ParametrizedGateImpl):
 
     @property
     def power(self):
-        return self.parameter/np.pi
+        return self.parameter / np.pi
 
-    def __init__(self, name, generator: QubitHamiltonian,  target: list, power, control: list = None):
+    def __init__(self, name, generator: QubitHamiltonian, target: list, power, control: list = None):
         if generator is None:
             assert name is not None and name.upper() in ["X", "Y", "Z"]
             generator = QubitHamiltonian.from_string("{}({})".format(name.upper(), target))
@@ -376,24 +410,43 @@ class GeneralizedRotationImpl(DifferentiableGateImpl):
             targets += [k for k in ps.keys()]
         return tuple(set(targets))
 
-    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:
+    def __init__(
+        self,
+        angle,
+        generator,
+        p0=None,
+        control=None,
+        target=None,
+        eigenvalues_magnitude=0.5,
+        steps=1,
+        name="GenRot",
+        assume_real=False,
+    ):
+        if target is 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)
+        super().__init__(
+            eigenvalues_magnitude=eigenvalues_magnitude,
+            generator=generator,
+            assume_real=assume_real,
+            name=name,
+            parameter=angle,
+            target=target,
+            control=control,
+        )
         self.steps = steps
         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)
+            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)
+            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):
@@ -403,17 +456,18 @@ class GeneralizedRotationImpl(DifferentiableGateImpl):
             return circuits
 
         r = 0.25
-        s = 0.5*np.pi
-        
+        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
+        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
+        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])]
+
 
-        return [(2.0 * r, [Up1,  Up2]), (-2.0 * r, [Um1, Um2])]
-        
 class ExponentialPauliGateImpl(DifferentiableGateImpl):
     """
     Same convention as for rotation gates:
@@ -421,7 +475,13 @@ class ExponentialPauliGateImpl(DifferentiableGateImpl):
     """
 
     def __init__(self, paulistring: PauliString, angle: float, control: typing.List[int] = None):
-        super().__init__(eigenvalues_magnitude=0.5, name="Exp-Pauli", target=tuple(t for t in paulistring.keys()), control=control, parameter=angle)
+        super().__init__(
+            eigenvalues_magnitude=0.5,
+            name="Exp-Pauli",
+            target=tuple(t for t in paulistring.keys()),
+            control=control,
+            parameter=angle,
+        )
         self.paulistring = paulistring
         self.generator = QubitHamiltonian.from_paulistrings(paulistring)
         self.finalize()
@@ -443,13 +503,16 @@ class ExponentialPauliGateImpl(DifferentiableGateImpl):
 
 
 class TrotterizedGateImpl(ParametrizedGateImpl):
-
-    def __init__(self, generator: QubitHamiltonian,
-                 angle: typing.Union[numbers.Real, Variable],
-                 steps: int = 1,
-                 control: typing.Union[list, int] = None,
-                 threshold: numbers.Real = 0.0,
-                 randomize: bool = True, **kwargs):
+    def __init__(
+        self,
+        generator: QubitHamiltonian,
+        angle: typing.Union[numbers.Real, Variable],
+        steps: int = 1,
+        control: typing.Union[list, int] = None,
+        threshold: numbers.Real = 0.0,
+        randomize: bool = True,
+        **kwargs,
+    ):
         """
         :param generators: list of generators
         :param angles: coefficients for each generator
@@ -463,7 +526,13 @@ class TrotterizedGateImpl(ParametrizedGateImpl):
         assert angle is not None
         assert generator is not None
 
-        super().__init__(name="Trotterized", target=self.extract_targets(generator), control=control, generator=generator, parameter=angle)
+        super().__init__(
+            name="Trotterized",
+            target=self.extract_targets(generator),
+            control=control,
+            generator=generator,
+            parameter=angle,
+        )
         self._parameter = angle
         self.steps = steps
         self.threshold = threshold
@@ -486,4 +555,3 @@ class TrotterizedGateImpl(ParametrizedGateImpl):
         for ps in generator.paulistrings:
             targets += [k for k in ps.keys()]
         return tuple(set(targets))
-