refactor Compiler

.github/workflows/ci_optimizers.yml

@@ -0,0 +1,39 @@
+# This workflow will install Python dependencies, run tests and lint with a variety of Python versions
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-python-with-github-actions
+
+name: Tequila-Test-Optimizers
+
+on:
+  push:
+    branches: [ master, devel ]
+  pull_request:
+    branches: [ master, devel ]
+
+jobs:
+
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.6, 3.7, 3.8]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v1
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install quantum backends
+      run: |
+              pip install --upgrade cirq qiskit qulacs
+
+    - name: Install and test GPyOpt interface (no qibo)
+      run: |  
+              python -m pip install --upgrade pip 
+              pip install --upgrade -r requirements.txt
+              pip install --upgrade -r requirements_gpyopt.txt
+              pip install -e .
+
+              pytest tests/test_gpyopt.py --slow
+

README.md

@@ -6,9 +6,9 @@ Tequila is an Extensible Quantum Information and Learning Architecture where the
 It operates on abstract data structures allowing the formulation, combination, automatic differentiation and optimization of generalized objectives.
 Tequila can execute the underlying quantum expectation values on state of the art simulators as well as on real quantum devices.
 
-[You can get an overview from this presentation](/docs/tequila.pdf)  
+[You can get an overview from this presentation](/docs/tequila.pdf) or from it's [video recording](https://www.youtube.com/watch?v=hUdf0P2fW2E)  
 
-[Get started with our Tutorials](/tutorials/)  
+[Get started with our Tutorials](https://github.com/aspuru-guzik-group/tequila-tutorials)  
 
 or checkout our [overview article](https://arxiv.org/abs/2011.03057)  
 
@@ -22,12 +22,23 @@ Currently supported
 
 Tequila detects backends automatically if they are installed on your systems.  
 All of them are available over standard pip installation like for example `pip install qulacs`.  
-For best performance tt is recommended to have `qulacs` installed.
+For best performance it is recommended to have `qulacs` installed.
 
 # QuantumChemistry:
-Tequila supports [Psi4](https://github.com/psi4/psi4).  
+Currently supported
+- [Psi4](https://github.com/psi4/psi4).  
 In a conda environment this can be installed with  
-`conda install psi4 -c psi4`
+```bash
+conda install psi4 -c psi4
+```
+Here is a small [tutorial](https://github.com/aspuru-guzik-group/tequila-tutorials/blob/main/Chemistry.ipynb) that illustrates the usage. 
+
+- [Madness](https://github.com/kottmanj/madness)  
+Currently you need to compile from a separate [fork](https://github.com/kottmanj/madness).  
+See the github page of this fork for installation instruction.  
+Note that the madness interface is currently only available on the `devel` branch of tequila (coming to master soon).  
+Here is a small [tutorial](https://github.com/aspuru-guzik-group/tequila-tutorials/blob/main/ChemistryMadnessInterface.ipynb) that illustrates the usage.  
+
 
 # Installation
 We recommend installing in editable mode with  
@@ -124,6 +135,10 @@ Quantum Computer-Aided design of Quantum Optics Hardware.
 [arxiv.org/abs/2006.03075](https://arxiv.org/abs/2006.03075)
 [example code](https://github.com/kottmanj/Photonic)  
 
+A. Anand, M. Degroote, A. Aspuru-Guzik.  
+Natural Evolutionary Strategies for Variational Quantum Computation.  
+[arxiv.org/abs/2012.00101](https://arxiv.org/abs/2012.00101)  
+
 Let us know, if you want your research project to be included in this list!
 
 # Dependencies
@@ -185,4 +200,5 @@ They can be installed for example over visual studio.
 Tequila runs on Macs OSX.  
 You might get in trouble with installing qulacs since it currently does not work with Apple's clang compiler.  
 You need to install latest GNU compile (at least gcc-7 and g++7) and set them as default before installing qulacs over pip.  
-
+## Qibo and GPyOpt
+Currently you can't use Qibo and GPyOpt within the same environment

requirements.txt

@@ -6,7 +6,7 @@ jaxlib
 #autograd # use if jaxlib gives you trouble, make sure jax is uninstalled then
 setuptools 
 pytest
-openfermion
+openfermion <= 0.11*
 cmake # needed by qulacs, can be removed otherwise
 qulacs # default simulator, remove if the installation gives you trouble
 
@@ -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

@@ -6,6 +6,7 @@
 from tequila.objective.objective import Variable, FixedVariable, assign_variable,Objective,VectorObjective
 from tequila.hamiltonian import PauliString, QubitHamiltonian, paulis
 from tequila.tools import list_assignment
+from numpy import pi
 
 from dataclasses import dataclass
 
@@ -30,11 +31,16 @@ 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 []
@@ -53,13 +59,6 @@ def __init__(self, name, target: UnionList, control: UnionList = None, generator
         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):
@@ -96,6 +95,16 @@ 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") 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"):
+            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__()))
+
 
     def __str__(self):
         result = str(self.name) + "(target=" + str(self.target)
@@ -131,14 +140,12 @@ 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 self.generator:
-            mapped.generator = self.generator.map_qubits(qubit_map)
+        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]
         mapped.finalize()
         return mapped
 
@@ -275,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]
+    """
 
-    def __init__(self, name, target: list, power=None, control: list = None, generator: QubitHamiltonian = None):
-        super().__init__(name=name, parameter=power, target=target, control=control, generator=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, 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
@@ -428,8 +456,3 @@ def dagger(self):
             angles.append(-angle)
         result.angles = angles
         return result
-
-    def map_qubits(self, qubit_map: dict):
-        mapped = super().map_qubits(qubit_map=qubit_map)
-        mapped.generators = [generator.map_qubits(qubit_map=qubit_map) for generator in mapped.generators]
-        return mapped