[Documentation] Update docs qpu + adiabatic to use min_avg_amp (#75)

* update docs on qpu submissions

* bump version

* new adiabatic algo

* reput as before adiabatic

* new qoolqit dependency

* use average of coefficients in adiabatic

* change custom adiabatic

Author: chMoussa

docs/content/backend.md

@@ -109,6 +109,7 @@ if PASSWORD is not None:
 We can also target a remote QPU as follows:
 
 ```python exec="on" source="material-block"
+import qoolqit
 from qubosolver.config import SolverConfig, PasqalCloud, QPU
 from pulser_pasqal.backends import EmuFreeBackendV2, EmuMPSBackend
 
@@ -122,9 +123,11 @@ if PASSWORD is not None:
         password=PASSWORD,
         project_id=PROJECT_ID,
     )
+    # specify the QPU device
+    device = qoolqit.devices.Device(pulser_device=connection.fetch_available_devices()["FRESNEL"])
     config = SolverConfig(
         use_quantum=True,
-        backend = QPU(connection=connection, runs=500),
+        backend = QPU(connection=connection, runs=500), device=device,
     )
 
 ```

docs/content/driveshaping/adiabatic.md

@@ -40,9 +40,9 @@ For the Adiabatic Drive, the values of the amplitude $\Omega$ (Rabi frequency) a
 
 - Amplitude: has a sine-like shape, starting from $0$ and ending in $0$, with a maximum value being the maximum value among the off-diagonal terms of the QUBO matrix:
 
-$$\Omega_{max} = max(Q_{off})$$
+$$\Omega_{max} = mean(Q_{ij, i != j})$$
 
-If $\Omega_{max}$ reaches a value above the maximum amplitude allowed by the device, it uses the `max_amp` value taken from the device specs as $\Omega_{max}$.
+If $\Omega_{max}$ reaches a value above the maximum amplitude allowed by the device, it uses the `max_amp` value taken from the device specs as $\Omega_{max}$. It it is below the `min_avg_amp` value from the specs, we use `min_avg_amp`.
 
 - Detuning: starts from a negative value $\delta_0$ that is the minimum value among the diagonal terms of the QUBO matrix (since diagonal terms are either negative or $0$), reaches $0$ and ends in a positive final value $\delta_f$, following a linear behavior:
 

docs/content/driveshaping/custom.md

@@ -53,8 +53,9 @@ class LimitedAdiabaticDriveShaper(BaseDriveShaper):
 
         rydberg_global = self.device._device.channels["rydberg_global"]
 
+        mean_coeffs = torch.mean(off_diag).item()
         Omega = min(
-            torch.max(off_diag).item(),
+            max(mean_coeffs, rydberg_global.min_avg_amp),
             rydberg_global.max_amp - 1e-9,
         )
 

docs/tutorial/00-a-tour-of-qubo.ipynb

@@ -370,6 +370,7 @@
    "outputs": [],
    "source": [
     "from qubosolver.config import QPU, PasqalCloud\n",
+    "import qoolqit\n",
     "\n",
     "# Replace with your username, project id and password on the Pasqal Cloud.\n",
     "USERNAME=\"username\"\n",
@@ -382,7 +383,9 @@
     "        password=PASSWORD,\n",
     "        project_id=PROJECT_ID,\n",
     "    )\n",
-    "    config = SolverConfig(use_quantum=True, backend=QPU(connection=connection))\n",
+    "    # specify the QPU device\n",
+    "    device = qoolqit.devices.Device(pulser_device=connection.fetch_available_devices()[\"FRESNEL\"])\n",
+    "    config = SolverConfig(use_quantum=True, backend=QPU(connection=connection), device=device)\n",
     "    # Run the solver\n",
     "    solver = QuboSolver(instance, config)\n",
     "    solutions = solver.solve()\n",

pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 name = "qubo-solver"
 description = "A Quadratic Unconstrained Binary Optimization (QUBO) solver library using quantum and classical approaches."
 readme = "README.md"
-version = "0.4.0"
+version = "0.4.1"
 requires-python = ">=3.10,<3.13"
 license = { text = "MIT-derived" }
 keywords = ["quantum", "qubo", "solver", "optimization", "combinatorial"]
@@ -42,7 +42,7 @@ dependencies = [
   "PyMaxflow",
   "cplex",
   "pydantic>=2",
-  "qoolqit[solvers]==0.3.0",
+  "qoolqit[solvers]==0.3.1",
   "shapely",
 ]
 

qubosolver/config.py

@@ -450,7 +450,7 @@ def _set_greedy_traps_greedy_spacing_from_device(self) -> SolverConfig:
             if hasattr(device, "min_layout_traps"):
                 if self.embedding.greedy_traps < device.min_layout_traps:
                     self.embedding = self.embedding.model_copy(
-                        update={"greedy_traps": device.value.min_layout_traps}
+                        update={"greedy_traps": device.min_layout_traps}
                     )
             if hasattr(device, "min_atom_distance"):
                 greedy_spacing_device = float(device.min_atom_distance)

qubosolver/pipeline/basesolver.py

@@ -214,6 +214,7 @@ def preprocess(self) -> None:
             if (
                 self.fixtures.reduced_qubo.coefficients is not None
                 and len(self.fixtures.reduced_qubo.coefficients) > 0
+                and self.fixtures.n_fixed_variables < self.instance.size  # type:ignore[operator]
             ):
 
                 self.instance = self.fixtures.reduced_qubo

qubosolver/pipeline/drive.py

@@ -83,6 +83,31 @@ class AdiabaticDriveShaper(BaseDriveShaper):
     A Standard Adiabatic Drive shaper.
     """
 
+    def _find_max_interaction_coeff_vectorized(self) -> float:
+        """
+        Finds the maximum q_ij such that q_ii + q_jj + q_ij + q_ji < 0,
+        using vectorized operations.
+
+        Returns:
+            float: The maximum q_ij value found, inf if no value satisfies
+                the confition.
+        """
+        Q = self.instance.coefficients
+        n = Q.shape[0]
+        i_indices, j_indices = torch.meshgrid(torch.arange(n), torch.arange(n), indexing="ij")
+        q_ii = Q[i_indices, i_indices]
+        q_jj = Q[j_indices, j_indices]
+
+        q_ij = Q[i_indices, j_indices]
+        q_ji = Q[j_indices, i_indices]
+
+        condition_mask = (q_ii + q_jj + q_ij + q_ji) < 0
+        valid_q_ij_values = Q[condition_mask]
+        if valid_q_ij_values.numel() == 0:
+            return float("inf")
+
+        return float(torch.max(valid_q_ij_values).cpu().item())
+
     def generate(
         self,
         register: Register,
@@ -113,22 +138,25 @@ def generate(
         max_node_weight = max(weights_list)
         norm_weights_list = [(1 - (w / max_node_weight)) / TIME for w in weights_list]
 
+        rydberg_global = self.device._device.channels["rydberg_global"]
+
         off_diag = QUBO[
             ~torch.eye(QUBO.shape[0], dtype=torch.bool)
         ]  # Selecting off-diagonal terms of the Qubo with a mask
 
-        rydberg_global = self.device._device.channels["rydberg_global"]
-
+        mean_coeffs = torch.mean(off_diag).item()
         Omega = min(
-            torch.max(off_diag).item(),
+            max(mean_coeffs, rydberg_global.min_avg_amp),
             rydberg_global.max_amp - 1e-9,
         )
 
         delta_0 = torch.min(torch.diag(QUBO)).item()
         delta_f = -delta_0
 
         # enforces AnalogDevice max sequence duration since Digital's has no max duration
-        max_seq_duration = AnalogDevice.max_sequence_duration
+        max_seq_duration = (
+            self.device._device.max_sequence_duration or AnalogDevice.max_sequence_duration
+        )
         assert max_seq_duration is not None
 
         max_seq_duration /= TIME