ommx-openjij-adapter 2.0.0b3__tar.gz → 2.0.0rc2__tar.gz

{ommx_openjij_adapter-2.0.0b3 → ommx_openjij_adapter-2.0.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommx_openjij_adapter
-Version: 2.0.0b3
+Version: 2.0.0rc2
 Summary: OMMX Adapter for OpenJij.
 Author-email: "Jij Inc." <info@j-ij.com>
 Project-URL: Repository, https://github.com/Jij-Inc/ommx
@@ -14,8 +14,8 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: ommx<3.0.0,>=2.0.0b3
-Requires-Dist: openjij>=0.9.2
+Requires-Dist: ommx<3.0.0,>=2.0.0rc1
+Requires-Dist: openjij<0.10.0,>=0.9.2
 
 OMMX Adapter for OpenJij
 =========================

{ommx_openjij_adapter-2.0.0b3 → ommx_openjij_adapter-2.0.0rc2}/ommx_openjij_adapter/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from ommx.v1 import Instance, State, Samples, SampleSet
+from ommx.v1 import Instance, State, Samples, SampleSet, DecisionVariable, Constraint
 from ommx.adapter import SamplerAdapter
 import openjij as oj
 from typing_extensions import deprecated
@@ -10,21 +10,21 @@ import copy
 
 class OMMXOpenJijSAAdapter(SamplerAdapter):
     """
-    Sampling QUBO with Simulated Annealing (SA) by `openjij.SASampler <https://openjij.github.io/OpenJij/reference/openjij/index.html#openjij.SASampler>`_
+    Sampling QUBO or HUBO with Simulated Annealing (SA) by `openjij.SASampler <https://openjij.github.io/OpenJij/reference/openjij/index.html#openjij.SASampler>`_
     """
 
     ommx_instance: Instance
     """
-    ommx.v1.Instance representing a QUBO problem
+    ommx.v1.Instance representing a QUBO or HUBO problem
 
-    The input `instance` must be a QUBO (Quadratic Unconstrained Binary Optimization) problem, i.e.
+    The input `instance` must be a QUBO (Quadratic Unconstrained Binary Optimization) or HUBO (Higher-order Unconstrained Binary Optimization) problem, i.e.
 
-    - Every decision variables are binary
-    - No constraint
-    - Objective function is quadratic
+    - All decision variables are binary
+    - No constraints
+    - Objective function is quadratic (QUBO) or higher (HUBO).
     - Minimization problem
 
-    You can convert an instance to QUBO via :meth:`ommx.v1.Instance.penalty_method` or other corresponding method.
+    You can convert an instance to QUBO or HUBO via :meth:`ommx.v1.Instance.penalty_method` or other corresponding method.
     """
 
     beta_min: float | None = None
@@ -36,24 +36,26 @@ class OMMXOpenJijSAAdapter(SamplerAdapter):
     num_reads: int | None = None
     """ number of reads """
     schedule: list | None = None
-    """ list of inverse temperature """
+    """ list of inverse temperature (parameter only used if problem is QUBO)"""
     initial_state: list | dict | None = None
-    """ initial state """
+    """ initial state (parameter only used if problem is QUBO)"""
     updater: str | None = None
     """ updater algorithm """
     sparse: bool | None = None
-    """ use sparse matrix or not """
+    """ use sparse matrix or not (parameter only used if problem is QUBO)"""
     reinitialize_state: bool | None = None
-    """ if true reinitialize state for each run """
+    """ if true reinitialize state for each run (parameter only used if problem is QUBO)"""
     seed: int | None = None
     """ seed for Monte Carlo algorithm """
 
     uniform_penalty_weight: Optional[float] = None
-    """ Weight for uniform penalty, passed to ``Instance.to_qubo`` """
+    """ Weight for uniform penalty, passed to ``Instance.to_qubo`` or ``Instance.to_hubo`` """
     penalty_weights: dict[int, float] = {}
-    """ Penalty weights for each constraint, passed to ``Instance.to_qubo`` """
+    """ Penalty weights for each constraint, passed to ``Instance.to_qubo`` or ``Instance.to_hubo`` """
     inequality_integer_slack_max_range: int = 32
-    """ Max range for integer slack variables in inequality constraints, passed to ``Instance.to_qubo`` """
+    """ Max range for integer slack variables in inequality constraints, passed to ``Instance.to_qubo`` or ``Instance.to_hubo`` """
+
+    _instance_prepared: bool = False
 
     @classmethod
     def sample(
@@ -139,30 +141,123 @@ class OMMXOpenJijSAAdapter(SamplerAdapter):
         return decode_to_samples(data)
 
     @property
-    def sampler_input(self) -> dict[tuple[int, int], float]:
-        qubo, _offset = self.ommx_instance.to_qubo(
-            uniform_penalty_weight=self.uniform_penalty_weight,
-            penalty_weights=self.penalty_weights,
-            inequality_integer_slack_max_range=self.inequality_integer_slack_max_range,
-        )
-        return qubo
+    def sampler_input(self) -> dict[tuple[int, ...], float]:
+        self._prepare_convert()
+        if self._is_hubo:
+            return self._hubo
+        else:
+            return self._qubo
 
     def _sample(self) -> oj.Response:
         sampler = oj.SASampler()
-        qubo = self.sampler_input
-        return sampler.sample_qubo(
-            qubo,  # type: ignore
-            beta_min=self.beta_min,
-            beta_max=self.beta_max,
-            num_sweeps=self.num_sweeps,
-            num_reads=self.num_reads,
-            schedule=self.schedule,
-            initial_state=self.initial_state,
-            updater=self.updater,
-            sparse=self.sparse,
-            reinitialize_state=self.reinitialize_state,
-            seed=self.seed,
-        )
+        input = self.sampler_input
+        if self._is_hubo:
+            return sampler.sample_hubo(
+                input,  # type: ignore
+                vartype="BINARY",
+                beta_min=self.beta_min,
+                beta_max=self.beta_max,
+                # maintaining default parameters in openjij impl if None passed
+                num_sweeps=self.num_sweeps or 1000,
+                num_reads=self.num_reads or 1,
+                updater=self.updater or "METROPOLIS",
+                seed=self.seed,
+            )
+
+        else:
+            return sampler.sample_qubo(
+                input,  # type: ignore
+                beta_min=self.beta_min,
+                beta_max=self.beta_max,
+                num_sweeps=self.num_sweeps,
+                num_reads=self.num_reads,
+                schedule=self.schedule,
+                initial_state=self.initial_state,
+                updater=self.updater,
+                sparse=self.sparse,
+                reinitialize_state=self.reinitialize_state,
+                seed=self.seed,
+            )
+
+    # Manually perform the conversion process to QUBO/HUBO, instead of using
+    # `to_hubo` or `to_qubo`.
+    #
+    # This is so that we can manually call `as_hubo_format()`, check if the
+    # finalized instance is higher-order, and if not, call
+    # `as_qubo_format()`.
+    #
+    # We could do alternative methods like simply checking the degrees of
+    # the objective function and all constraints. But some instances will
+    # see to be higher-order but ultimately representable as QUBO after the
+    # conversion (eg. due to simplifying binary `x * x`). So we chose to do
+    # it this way.
+    def _prepare_convert(self):
+        if self._instance_prepared:
+            return
+
+        self.ommx_instance.as_minimization_problem()
+
+        continuous_variables = [
+            var.id
+            for var in self.ommx_instance.decision_variables
+            if var.kind == DecisionVariable.CONTINUOUS
+        ]
+        if len(continuous_variables) > 0:
+            raise ValueError(
+                f"Continuous variables are not supported in HUBO conversion: IDs={continuous_variables}"
+            )
+
+        # Prepare inequality constraints
+        ineq_ids = [
+            c.id
+            for c in self.ommx_instance.constraints
+            if c.equality == Constraint.LESS_THAN_OR_EQUAL_TO_ZERO
+        ]
+        for ineq_id in ineq_ids:
+            try:
+                self.ommx_instance.convert_inequality_to_equality_with_integer_slack(
+                    ineq_id, self.inequality_integer_slack_max_range
+                )
+            except RuntimeError:
+                self.ommx_instance.add_integer_slack_to_inequality(
+                    ineq_id, self.inequality_integer_slack_max_range
+                )
+
+        # Penalty method
+        if self.ommx_instance.constraints:
+            if self.uniform_penalty_weight is not None and self.penalty_weights:
+                raise ValueError(
+                    "Both uniform_penalty_weight and penalty_weights are specified. Please choose one."
+                )
+            if self.penalty_weights:
+                pi = self.ommx_instance.penalty_method()
+                weights = {
+                    p.id: self.penalty_weights[p.subscripts[0]] for p in pi.parameters
+                }
+                unconstrained = pi.with_parameters(weights)
+            else:
+                if self.uniform_penalty_weight is None:
+                    # If both are None, defaults to uniform_penalty_weight = 1.0
+                    self.uniform_penalty_weight = 1.0
+                pi = self.ommx_instance.uniform_penalty_method()
+                weight = pi.parameters[0]
+                unconstrained = pi.with_parameters(
+                    {weight.id: self.uniform_penalty_weight}
+                )
+            self.ommx_instance.raw = unconstrained.raw
+
+        self.ommx_instance.log_encode()
+
+        hubo, _ = self.ommx_instance.as_hubo_format()
+        if any(len(k) > 2 for k in hubo.keys()):
+            self._is_hubo = True
+            self._hubo = hubo
+        else:
+            self._is_hubo = False
+            qubo, _ = self.ommx_instance.as_qubo_format()
+            self._qubo = qubo
+
+        self._instance_prepared = True
 
 
 @deprecated("Renamed to `decode_to_samples`")
@@ -177,23 +272,24 @@ def decode_to_samples(response: oj.Response) -> Samples:
     """
     Convert `openjij.Response <https://openjij.github.io/OpenJij/reference/openjij/index.html#openjij.Response>`_ to :class:`Samples`
     """
-    # Filling into ommx.v1.Samples
+    # Create empty samples and append each state with its sample IDs
     # Since OpenJij does not issue the sample ID, we need to generate it in the responsibility of this OMMX Adapter
+    samples = Samples({})  # Create empty samples
     sample_id = 0
-    entries = []
 
     num_reads = len(response.record.num_occurrences)
     for i in range(num_reads):
         sample = response.record.sample[i]
-        state = State(entries=zip(response.variables, sample))  # type: ignore
+        state = State(entries=zip(response.variables, sample))
         # `num_occurrences` is encoded into sample ID list.
         # For example, if `num_occurrences` is 2, there are two samples with the same state, thus two sample IDs are generated.
         ids = []
         for _ in range(response.record.num_occurrences[i]):
             ids.append(sample_id)
             sample_id += 1
-        entries.append(Samples.SamplesEntry(state=state, ids=ids))
-    return Samples(entries=entries)
+        samples.append(ids, state)
+
+    return samples
 
 
 @deprecated("Use `OMMXOpenJijSAAdapter.sample` instead")

{ommx_openjij_adapter-2.0.0b3 → ommx_openjij_adapter-2.0.0rc2}/ommx_openjij_adapter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommx_openjij_adapter
-Version: 2.0.0b3
+Version: 2.0.0rc2
 Summary: OMMX Adapter for OpenJij.
 Author-email: "Jij Inc." <info@j-ij.com>
 Project-URL: Repository, https://github.com/Jij-Inc/ommx
@@ -14,8 +14,8 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: ommx<3.0.0,>=2.0.0b3
-Requires-Dist: openjij>=0.9.2
+Requires-Dist: ommx<3.0.0,>=2.0.0rc1
+Requires-Dist: openjij<0.10.0,>=0.9.2
 
 OMMX Adapter for OpenJij
 =========================

ommx_openjij_adapter-2.0.0rc2/ommx_openjij_adapter.egg-info/requires.txt

@@ -0,0 +1,2 @@
+ommx<3.0.0,>=2.0.0rc1
+openjij<0.10.0,>=0.9.2

{ommx_openjij_adapter-2.0.0b3 → ommx_openjij_adapter-2.0.0rc2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ommx_openjij_adapter"
-version = "2.0.0b3"
+version = "2.0.0rc2"
 
 description = "OMMX Adapter for OpenJij."
 authors = [{ name = "Jij Inc.", email = "info@j-ij.com" }]
@@ -22,7 +22,7 @@ classifiers = [
   "License :: OSI Approved :: Apache Software License",
   "License :: OSI Approved :: MIT License",
 ]
-dependencies = ["ommx >= 2.0.0b3, < 3.0.0", "openjij >= 0.9.2"]
+dependencies = ["ommx >= 2.0.0rc1, < 3.0.0", "openjij >= 0.9.2, < 0.10.0"]
 
 [project.urls]
 Repository = "https://github.com/Jij-Inc/ommx"

{ommx_openjij_adapter-2.0.0b3 → ommx_openjij_adapter-2.0.0rc2}/tests/test_sample.py

@@ -95,6 +95,68 @@ def integer_inequality():
     return pytest.param(instance, ans, id="integer_inequality")
 
 
+def hubo_binary_no_constraint_minimize():
+    x0 = DecisionVariable.binary(0, name="x", subscripts=[0])
+    x1 = DecisionVariable.binary(1, name="x", subscripts=[1])
+    x2 = DecisionVariable.binary(2, name="x", subscripts=[2])
+    instance = Instance.from_components(
+        decision_variables=[x0, x1, x2],
+        objective=x0 + x0 * x1 * x2,
+        constraints=[],
+        sense=Instance.MINIMIZE,
+    )
+    ans = {(0,): 0.0, (1,): 0.0, (2,): 0.0}
+    return pytest.param(instance, ans, id="hubo_binary_no_constraint_minimize")
+
+
+def hubo_binary_no_constraint_maximize():
+    x0 = DecisionVariable.binary(0, name="x", subscripts=[0])
+    x1 = DecisionVariable.binary(1, name="x", subscripts=[1])
+    x2 = DecisionVariable.binary(2, name="x", subscripts=[2])
+    instance = Instance.from_components(
+        decision_variables=[x0, x1, x2],
+        objective=x0 + x0 * x1 * x2,
+        constraints=[],
+        sense=Instance.MAXIMIZE,
+    )
+    ans = {(0,): 1.0, (1,): 1.0, (2,): 1.0}
+    return pytest.param(instance, ans, id="hubo_binary_no_constraint_maximize")
+
+
+def hubo_binary_equality():
+    x0 = DecisionVariable.binary(0, name="x", subscripts=[0])
+    x1 = DecisionVariable.binary(1, name="x", subscripts=[1])
+    x2 = DecisionVariable.binary(2, name="x", subscripts=[2])
+
+    instance = Instance.from_components(
+        decision_variables=[x0, x1, x2],
+        objective=x0 + 2 * x1 + 3 * x2 + x0 * x1 * x2,
+        constraints=[x1 * x2 == 0],
+        sense=Instance.MAXIMIZE,
+    )
+
+    # x0 = x2 = 1, x1 = 0 is maximum
+    ans = {(0,): 1.0, (1,): 0.0, (2,): 1.0}
+    return pytest.param(instance, ans, id="hubo_binary_equality")
+
+
+def hubo_binary_inequality():
+    x0 = DecisionVariable.binary(0, name="x", subscripts=[0])
+    x1 = DecisionVariable.binary(1, name="x", subscripts=[1])
+    x2 = DecisionVariable.binary(2, name="x", subscripts=[2])
+
+    instance = Instance.from_components(
+        decision_variables=[x0, x1, x2],
+        objective=x0 + 2 * x1 + 3 * x2 + x0 * x1 * x2,
+        constraints=[x0 + x1 + x2 <= 2],
+        sense=Instance.MAXIMIZE,
+    )
+
+    # x1 = x2 = 1, x0 = 0 is maximum
+    ans = {(0,): 0.0, (1,): 1.0, (2,): 1.0}
+    return pytest.param(instance, ans, id="hubo_binary_inequality")
+
+
 @pytest.mark.parametrize(
     "instance, ans",
     [
@@ -104,11 +166,15 @@ def integer_inequality():
         binary_inequality(),
         integer_equality(),
         integer_inequality(),
+        hubo_binary_no_constraint_minimize(),
+        hubo_binary_no_constraint_maximize(),
+        hubo_binary_equality(),
+        hubo_binary_inequality(),
     ],
 )
 def test_sample(instance, ans):
     sample_set = OMMXOpenJijSAAdapter.sample(
-        instance, num_reads=1, uniform_penalty_weight=3.0, seed=12345
+        instance, num_reads=1, uniform_penalty_weight=3.0, seed=999
     )
     assert sample_set.extract_decision_variables("x", 0) == ans
 
@@ -122,11 +188,15 @@ def test_sample(instance, ans):
         binary_inequality(),
         integer_equality(),
         integer_inequality(),
+        hubo_binary_no_constraint_minimize(),
+        hubo_binary_no_constraint_maximize(),
+        hubo_binary_equality(),
+        hubo_binary_inequality(),
     ],
 )
 def test_solve(instance, ans):
     solution = OMMXOpenJijSAAdapter.solve(
-        instance, num_reads=1, uniform_penalty_weight=3.0, seed=12345
+        instance, num_reads=1, uniform_penalty_weight=3.0, seed=999
     )
     assert solution.extract_decision_variables("x") == ans
 
@@ -140,6 +210,10 @@ def test_solve(instance, ans):
         binary_inequality(),
         integer_equality(),
         integer_inequality(),
+        hubo_binary_no_constraint_minimize(),
+        hubo_binary_no_constraint_maximize(),
+        hubo_binary_equality(),
+        hubo_binary_inequality(),
     ],
 )
 def test_sample_twice(instance, ans):

ommx_openjij_adapter-2.0.0b3/ommx_openjij_adapter.egg-info/requires.txt

@@ -1,2 +0,0 @@
-ommx<3.0.0,>=2.0.0b3
-openjij>=0.9.2