refactor Compiler + Generators

requirements.txt

@@ -16,3 +16,6 @@ qulacs # default simulator, remove if the installation gives you trouble
 #pyquil # you need to install the forest-sdk
 #qulacs-gpu
 #qibo <= 0.1.1
+
+#optional third party libraries
+#pyzx

src/tequila/__init__.py

@@ -14,6 +14,8 @@
     INSTALLED_SAMPLERS, \
     INSTALLED_SIMULATORS, SUPPORTED_BACKENDS, INSTALLED_BACKENDS, show_available_simulators
 from tequila.wavefunction import QubitWaveFunction
+from tequila.circuit.qasm import export_open_qasm, import_open_qasm, import_open_qasm_from_file
+from tequila.circuit.pyzx import convert_to_pyzx, convert_from_pyzx
 import tequila.quantumchemistry as chemistry # shortcut
 from tequila.quantumchemistry import Molecule, MoleculeFromOpenFermion
 

src/tequila/circuit/_gates_impl.py

@@ -4,8 +4,9 @@
 from abc import ABC
 from tequila import TequilaException
 from tequila.objective.objective import Variable, FixedVariable, assign_variable,Objective,VectorObjective
-from tequila.hamiltonian import PauliString, QubitHamiltonian
+from tequila.hamiltonian import PauliString, QubitHamiltonian, paulis
 from tequila.tools import list_assignment
+from numpy import pi
 
 from dataclasses import dataclass
 
@@ -30,30 +31,35 @@ def control(self):
 
     @property
     def qubits(self):
-        return self._qubits
+        # Set the active qubits
+        if self.control:
+            qubits = self.target + self.control
+        else:
+            qubits = self.target
+        return sorted(tuple(set(qubits)))
 
     @property
     def max_qubit(self):
-        return self._max_qubit
+        return self.compute_max_qubit()
 
     def extract_variables(self):
         return []
 
     def is_parametrized(self) -> bool:
         return hasattr(self, "parameter")
 
-    def __init__(self, name, target: UnionList, control: UnionList = None):
+    def make_generator(self, include_controls=False):
+        if self.generator and include_controls and self.is_controlled():
+            return paulis.Qm(self.control) * self.generator
+
+        return self.generator
+
+    def __init__(self, name, target: UnionList, control: UnionList = None, generator: QubitHamiltonian = None):
         self._name = name
         self._target = tuple(list_assignment(target))
         self._control = tuple(list_assignment(control))
         self.finalize()
-        # Set the active qubits
-        if self.control:
-            self._qubits = self.target + self.control
-        else:
-            self._qubits = self.target
-        self._qubits = sorted(tuple(set(self._qubits)))
-        self._max_qubit = self.compute_max_qubit()
+        self.generator = generator
 
     def copy(self):
         return copy.deepcopy(self)
@@ -89,7 +95,7 @@ def finalize(self):
             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"):
+        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__()))
         if hasattr(self, "generators"):
@@ -134,13 +140,9 @@ def __eq__(self, other):
     def map_qubits(self, qubit_map: dict):
         mapped = copy.deepcopy(self)
         mapped._target = tuple([qubit_map[i] for i in self.target])
-        qubits = mapped._target
         if self.control is not None:
             mapped._control = tuple([qubit_map[i] for i in self.control])
-            qubits += mapped._control
-        mapped._qubits = sorted(tuple(set(qubits)))
-        mapped._max_qubit = mapped.compute_max_qubit()
-        if hasattr(self, "generator"):
+        if hasattr(self, "generator") and self.generator:
             mapped.generator = self.generator.map_qubits(qubit_map=qubit_map)
         if hasattr(self, "generators"):
             mapped.generators = [i.map_qubits(qubit_map=qubit_map) for i in self.generators]
@@ -169,8 +171,9 @@ def parameter(self):
     def parameter(self, other):
         self.parameter = assign_variable(variable=other)
 
-    def __init__(self, name, parameter: UnionParam, target: UnionList, control: UnionList = None):
-        super().__init__(name=name, target=target, control=control)
+    def __init__(self, name, parameter: UnionParam, target: UnionList, control: UnionList = None,
+                generator: QubitHamiltonian = None):
+        super().__init__(name=name, target=target, control=control, generator=generator)
         if isinstance(parameter, VectorObjective):
             raise TequilaException('Received VectorObjective {} as parameter. This is forbidden.'.format(parameter))
         self._parameter = assign_variable(variable=parameter)
@@ -233,6 +236,7 @@ def __init__(self, axis, angle, target: list, control: list = None):
         assert (angle is not None)
         super().__init__(eigenvalues_magnitude=0.5, 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)
 
     @staticmethod
     def assign_axis(axis):
@@ -244,6 +248,15 @@ def assign_axis(axis):
             assert (axis in [0, 1, 2])
             return axis
 
+    @staticmethod
+    def assign_generator(axis, qubits):
+        if axis == 0:
+            return sum(paulis.X(q) for q in qubits)
+        if axis == 1:
+            return sum(paulis.Y(q) for q in qubits)
+
+        return sum(paulis.Z(q) for q in qubits)
+
     def dagger(self):
         result = copy.deepcopy(self)
         result._parameter = assign_variable(-self.parameter)
@@ -255,6 +268,7 @@ 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)
+        self.generator = paulis.Z(target) - paulis.I(target)
 
     def dagger(self):
         result = copy.deepcopy(self)
@@ -268,14 +282,35 @@ def __pow__(self, power, modulo=None):
 
 
 class PowerGateImpl(ParametrizedGateImpl):
+    """
+    Attributes
+    ---------
+    power
+        numeric type (fixed exponent) or hashable type (parametrized exponent)
+    parameter
+        power multiplied by pi
+        to be consitent with exp(-i a/2 G) representation [a: gate.parameter, G: gate.generator]
+    """
+
+    @property
+    def power(self):
+        return self._power
+
+    @power.setter
+    def power(self, other):
+        self._power = assign_variable(variable=other)
 
-    def __init__(self, name, target: list, power=None, control: list = None):
-        super().__init__(name=name, parameter=power, target=target, control=control)
+    def __init__(self, name, target: list, power, control: list = None, generator: QubitHamiltonian = None):
+        super().__init__(name=name, parameter=power * pi, target=target, control=control, generator=generator)
+        self._power = assign_variable(variable=power)
 
     def dagger(self):
         result = copy.deepcopy(self)
+        result._parameter = assign_variable(-self.parameter)
+        result._power = assign_variable(-self.power)
         return result
 
+
 class GeneralizedRotationImpl(DifferentiableGateImpl):
     """
     A gate which behaves like a generalized rotation
@@ -321,6 +356,7 @@ def dagger(self):
     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)
         self.paulistring = paulistring
+        self.generator = QubitHamiltonian.from_paulistrings(paulistring)
         self.finalize()
 
     def __str__(self):
@@ -420,4 +456,3 @@ def dagger(self):
             angles.append(-angle)
         result.angles = angles
         return result
-