remove parser

README.md

@@ -8,14 +8,13 @@ Boosting variational eigenstate preparation algorithms limited by training and n
 The package can be installed by source after cloning the repository:
 
 ```sh
-pip install -e .
+cd boostvqe
+pip install .
 ```
 
-will install `boostvqe 0.0.1` and activate a dedicated working shell.
-
 ## Code structure
 
-The file `main.py` performs boosted VQE training.
+The file `src/boostvqe/boost.py` performs boosted VQE training.
 
 The source code is located in `./src/boostvqe/.` and its composed of:
 
@@ -24,14 +23,24 @@ The source code is located in `./src/boostvqe/.` and its composed of:
 * `plotscripts.py`: plotting functions.
 * `compiling_XXZ.py`: compilation for XXZ model.
 
-## How to run the code
+## Example
 
-For further information about the inputs:
+It follows a python snippet explaining how to run the boosting
 
-```sh
-python main.py --help
+```py
+
+from boostvqe.boost import dbqa_vqe
+from boostvqe.ansatze import hdw_efficient
+
+from qibo.models.dbi.double_bracket import DoubleBracketGeneratorType
+
+circuit = hdw_efficient(nqubits=2, nlayers=2)
+output_folder = "output"
+dbqa_vqe(circuit, output_folder, mode = DoubleBracketGeneratorType.group_commutator)
 ```
 
+All the info regarding `dbqa_vqe` can be generated with `help(dbqa_vqe)`.
+
 # Tutorials
 
 Some useful notebooks to understand how the library works, are collected [here](notebooks/notebooks_links.md).

extras/compiling.py

@@ -78,28 +78,25 @@ def main(args):
     )
     vqe.circuit.set_parameters(params)
 
-    # this is the Hamiltonian that we are studying
     base_oracle = XXZ_EvolutionOracle.from_nqubits(
         nqubits=nqubits, delta=0.5, steps=args.steps, order=args.order
     )
-
-    # We rotate H_XXZ with VQE using the FrameShiftedOracle e^{i H' t} = V e^{i H0 t} Vdag
     oracle = FrameShiftedEvolutionOracle.from_evolution_oracle(
-        # before_circuit=vqe.circuit.invert(),
-        circuit_frame=vqe.circuit,
+        before_circuit=vqe.circuit.invert(),
+        after_circuit=vqe.circuit,
         base_evolution_oracle=base_oracle,
     )
 
-    # Shifted oracle is passed to the group commutator
     gci = GroupCommutatorIterationWithEvolutionOracles(
         oracle,
         args.db_rotation,
     )
 
+    # TODO: remove hardcoded magnetic field
     eo_d_type = getattr(double_bracket_evolution_oracles, args.eo_d)
 
     print(
-        f"The gci mode is {gci.mode} rotation with {eo_d_type.__name__} as the oracle.\n"
+        f"The gci mode is {gci.double_bracket_rotation_type} rotation with {eo_d_type.__name__} as the oracle.\n"
     )
     metadata = {}
 

pyproject.toml

@@ -12,9 +12,14 @@ packages = [{ include = "boostvqe", from = "src" }]
 
 [tool.poetry.dependencies]
 python = ">=3.9,<3.13"
-qibo = "^0.2.9"
 numpy = "^1.26.4"
 numba = "^0.59.0"
+qibo = "^0.2.12"
+tensorflow = "^2.17.0"
+matplotlib = "^3.9.2"
+seaborn = "^0.13.2"
+hyperopt = "^0.2.7"
+qibojit = "^0.1.6"
 
 [tool.poetry.group.dev.dependencies]
 ipython = "^7.34"

src/boostvqe/ansatze.py

@@ -5,14 +5,16 @@
 
 from boostvqe.training_utils import vqe_loss
 
+
 def connect_qubits(circuit, jumpsize=1, start_from=0):
     def get_circular_index(n, index):
         circular_index = index % n
         return circular_index
-    for q in range(start_from, circuit.nqubits, jumpsize+1):
+
+    for q in range(start_from, circuit.nqubits, jumpsize + 1):
         ctrl_index = q
-        targ_index = get_circular_index(circuit.nqubits, q+jumpsize)
-        circuit.add(gates.RBS(q0=ctrl_index, q1=targ_index, theta=0.))
+        targ_index = get_circular_index(circuit.nqubits, q + jumpsize)
+        circuit.add(gates.RBS(q0=ctrl_index, q1=targ_index, theta=0.0))
     return circuit
 
 
@@ -31,18 +33,16 @@ def hdw_efficient(nqubits, nlayers):
     circuit.add(gates.RY(q, theta=0) for q in range(nqubits))
 
     return circuit
-
 
-def hw_preserving(nqubits, nlayers=1):
 
-    if nqubits%2 != 0:
+def hw_preserving(nqubits, nlayers=1):
+    if nqubits % 2 != 0:
         raise_error(
-            ValueError,
-            "To use this ansatz please be sure number of qubits is even."
-    )
+            ValueError, "To use this ansatz please be sure number of qubits is even."
+        )
     c = Circuit(nqubits)
 
-    for q in range(int(nqubits/2)):
+    for q in range(int(nqubits / 2)):
         c.add(gates.X(q))
 
     for _ in range(int(nlayers)):
@@ -54,28 +54,30 @@ def hw_preserving(nqubits, nlayers=1):
 
     return c
 
+
 def su2_preserving(nqubits, nlayers):
     """SU2 invariant circuit."""
     c = Circuit(nqubits)
     for _ in range(nlayers):
         for q in range(1, nqubits, 2):
-            c.add(gates.RXX(q0=q, q1=(q+1)%nqubits, theta=0.))
-            c.add(gates.RYY(q0=q, q1=(q+1)%nqubits, theta=0.))
-            c.add(gates.RZZ(q0=q, q1=(q+1)%nqubits, theta=0.))
+            c.add(gates.RXX(q0=q, q1=(q + 1) % nqubits, theta=0.0))
+            c.add(gates.RYY(q0=q, q1=(q + 1) % nqubits, theta=0.0))
+            c.add(gates.RZZ(q0=q, q1=(q + 1) % nqubits, theta=0.0))
         for q in range(0, nqubits, 2):
-            c.add(gates.RXX(q0=q, q1=(q+1)%nqubits, theta=0.))
-            c.add(gates.RYY(q0=q, q1=(q+1)%nqubits, theta=0.))
-            c.add(gates.RZZ(q0=q, q1=(q+1)%nqubits, theta=0.))
+            c.add(gates.RXX(q0=q, q1=(q + 1) % nqubits, theta=0.0))
+            c.add(gates.RYY(q0=q, q1=(q + 1) % nqubits, theta=0.0))
+            c.add(gates.RZZ(q0=q, q1=(q + 1) % nqubits, theta=0.0))
     return c
 
+
 def compute_gradients(parameters, circuit, hamiltonian):
     """
     Compute gradients of circuit's parameters to check the problem trainability.
     The evaluated derivatives are the ones of the expectation of `hamiltonian`
     over the final state get running `circuit.execute` w.r.t. rotational angles.
 
     """
-    tf_backend = construct_backend("tensorflow")
+    tf_backend = construct_backend(backend="qiboml", platform="tensorflow")
     parameters = tf_backend.tf.Variable(parameters, dtype=tf_backend.tf.float64)
 
     with tf_backend.tf.GradientTape() as tape: