ommx-python-mip-adapter 3.0.0b3__tar.gz → 3.0.0b5__tar.gz

{ommx_python_mip_adapter-3.0.0b3 → ommx_python_mip_adapter-3.0.0b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommx_python_mip_adapter
-Version: 3.0.0b3
+Version: 3.0.0b5
 Summary: An adapter for the Python-MIP from/to OMMX.
 Author-email: "Jij Inc." <info@j-ij.com>
 Project-URL: Repository, https://github.com/Jij-Inc/ommx
@@ -15,7 +15,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: ommx<4.0.0,>=3.0.0b3
+Requires-Dist: ommx<4.0.0,>=3.0.0b5
 Requires-Dist: mip<2.0.0,>=1.17.0
 Requires-Dist: cffi<2.0.0,>=1.15.0
 

{ommx_python_mip_adapter-3.0.0b3 → ommx_python_mip_adapter-3.0.0b5}/ommx_python_mip_adapter/adapter.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copy
 from typing import ClassVar, Optional
 
 import mip
@@ -15,13 +16,13 @@ from ommx.adapter import (
 from ommx import (
     Constraint,
     DecisionVariable,
-    DegreeBound,
     Equality,
     Function,
     Instance,
     InstanceClass,
     InstanceClassClause,
     Kind,
+    PolynomialRequirement,
     PreparationPolicy,
     Sense,
     Solution,
@@ -34,20 +35,22 @@ from .exception import OMMXPythonMIPAdapterError
 
 _tracer = trace.get_tracer("ommx.adapter.python_mip")
 
-_LINEAR_CONSTRAINT_DEGREE_BOUNDS = {
-    Equality.EqualToZero: DegreeBound.at_most(1),
-    Equality.LessThanOrEqualToZero: DegreeBound.at_most(1),
+_LINEAR_CONSTRAINT_POLYNOMIAL_REQUIREMENTS = {
+    Equality.EqualToZero: PolynomialRequirement.at_most(1),
+    Equality.LessThanOrEqualToZero: PolynomialRequirement.at_most(1),
 }
 
 
 class OMMXPythonMIPAdapter(SolverAdapter):
-    INPUT_CLASS: ClassVar[InstanceClass | None] = InstanceClass(
+    INPUT_CLASS: ClassVar[InstanceClass] = InstanceClass(
         [
             InstanceClassClause(
                 label="python-mip-linear-mip",
                 allowed_variable_kinds={Kind.Binary, Kind.Integer, Kind.Continuous},
-                objective_degree_bound=DegreeBound.at_most(1),
-                regular_constraint_degree_bounds=_LINEAR_CONSTRAINT_DEGREE_BOUNDS,
+                objective_polynomial_requirement=PolynomialRequirement.at_most(1),
+                regular_constraint_polynomial_requirements=(
+                    _LINEAR_CONSTRAINT_POLYNOMIAL_REQUIREMENTS
+                ),
                 allowed_senses={Sense.Minimize, Sense.Maximize},
             )
         ]
@@ -59,8 +62,9 @@ class OMMXPythonMIPAdapter(SolverAdapter):
 
         Python-MIP currently accepts only regular constraints through this
         adapter. The recommendation therefore lowers the special-constraint
-        families currently understood by OMMX. The returned policy is fresh and
-        may be edited by the caller before :meth:`Instance.prepare` is invoked.
+        families currently understood by OMMX. The easy API applies a fresh
+        policy to an isolated copy; callers may instead edit and apply one
+        before invoking :meth:`solve_without_preparation`.
         """
         return PreparationPolicy(
             special_constraints=SpecialConstraintPreparation.lower_special_constraints(
@@ -131,7 +135,10 @@ class OMMXPythonMIPAdapter(SolverAdapter):
         """
         Solve the given ommx.Instance using Python-MIP, returning an ommx.Solution.
 
-        :param ommx_instance: The ommx.Instance to solve.
+        The input instance is not modified. An isolated copy is prepared with
+        the recommended Python-MIP policy before preparation-free execution.
+
+        :param ommx_instance: The ommx.Instance to prepare and solve.
         :param relax: If True, relax all integer variables to continuous variables by using the `relax` parameter in Python-MIP's `Model.optimize() <https://docs.python-mip.com/en/latest/classes.html#mip.Model.optimize>`.
         :param verbose: If True, enable Python-MIP's verbose mode
 
@@ -236,9 +243,28 @@ class OMMXPythonMIPAdapter(SolverAdapter):
                 1.0
 
         """
-        _ = diagnostics
+        prepared = copy.copy(ommx_instance)
+        prepared.prepare(cls.INPUT_CLASS, cls.recommended_preparation_policy())
+        return cls.solve_without_preparation(
+            prepared,
+            relax=relax,
+            verbose=verbose,
+            diagnostics=diagnostics,
+        )
+
+    @classmethod
+    def solve_without_preparation(
+        cls,
+        ommx_instance: Instance,
+        relax: bool = False,
+        verbose: bool = False,
+        *,
+        diagnostics: DiagnosticsSink | None = None,
+    ) -> Solution:
+        """Solve an exact Python-MIP Adapter input without preparing it."""
         with _tracer.start_as_current_span("solve") as span:
             span.set_attribute("adapter", f"{cls.__module__}.{cls.__qualname__}")
+            _ = diagnostics
             adapter = cls(ommx_instance, relax=relax, verbose=verbose)
             model = adapter.solver_input
             with _tracer.start_as_current_span("call"):
@@ -270,6 +296,10 @@ class OMMXPythonMIPAdapter(SolverAdapter):
         `solver_input`, you must set `solution.relaxation` yourself if you
         care about this value.
 
+        Backend optimality is mapped through the instance's output-objective
+        semantics. It remains unspecified when active-formulation optimality
+        does not transport to that objective.
+
         Examples
         =========
 
@@ -303,17 +333,22 @@ class OMMXPythonMIPAdapter(SolverAdapter):
             state = self.decode_to_state(data)
             solution = self.instance.evaluate(state)
 
-            dual_variables = {}
-            for constraint in data.constrs:
-                pi = constraint.pi
-                if pi is not None:
-                    id = int(constraint.name)
-                    dual_variables[id] = pi
-            for constraint_id, dual_value in dual_variables.items():
-                solution.set_dual_variable(constraint_id, dual_value)
+            # Duals certify the active formulation and need an explicit mapping
+            # before they can be attached to projected output semantics.
+            if self.instance.output_objective is None:
+                dual_variables = {}
+                for constraint in data.constrs:
+                    pi = constraint.pi
+                    if pi is not None:
+                        id = int(constraint.name)
+                        dual_variables[id] = pi
+                for constraint_id, dual_value in dual_variables.items():
+                    solution.set_dual_variable(constraint_id, dual_value)
 
             if data.status == mip.OptimizationStatus.OPTIMAL:
-                solution.optimality = Solution.OPTIMAL
+                solution.optimality = self.instance.map_active_optimality(
+                    Solution.OPTIMAL
+                )
 
             if self._relax:
                 solution.relaxation = Solution.LP_RELAXED
@@ -414,6 +449,11 @@ class OMMXPythonMIPAdapter(SolverAdapter):
         Translate ommx.Function to `mip.LinExpr` or `float`.
         """
         degree = f.degree()
+        if degree is None:
+            raise OMMXPythonMIPAdapterError(
+                "Non-polynomial functions are not supported. "
+                "Only linear (degree 1) and constant (degree 0) functions are supported."
+            )
         constant = f.constant_term
         if degree > 1:
             raise OMMXPythonMIPAdapterError(

{ommx_python_mip_adapter-3.0.0b3 → ommx_python_mip_adapter-3.0.0b5}/ommx_python_mip_adapter.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ommx_python_mip_adapter
-Version: 3.0.0b3
+Version: 3.0.0b5
 Summary: An adapter for the Python-MIP from/to OMMX.
 Author-email: "Jij Inc." <info@j-ij.com>
 Project-URL: Repository, https://github.com/Jij-Inc/ommx
@@ -15,7 +15,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: ommx<4.0.0,>=3.0.0b3
+Requires-Dist: ommx<4.0.0,>=3.0.0b5
 Requires-Dist: mip<2.0.0,>=1.17.0
 Requires-Dist: cffi<2.0.0,>=1.15.0
 

{ommx_python_mip_adapter-3.0.0b3 → ommx_python_mip_adapter-3.0.0b5}/ommx_python_mip_adapter.egg-info/requires.txt

@@ -1,3 +1,3 @@
-ommx<4.0.0,>=3.0.0b3
+ommx<4.0.0,>=3.0.0b5
 mip<2.0.0,>=1.17.0
 cffi<2.0.0,>=1.15.0

{ommx_python_mip_adapter-3.0.0b3 → ommx_python_mip_adapter-3.0.0b5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ommx_python_mip_adapter"
-version = "3.0.0b3"
+version = "3.0.0b5"
 
 description = "An adapter for the Python-MIP from/to OMMX."
 authors = [{ name = "Jij Inc.", email = "info@j-ij.com" }]
@@ -23,7 +23,7 @@ classifiers = [
 ]
 
 dependencies = [
-  "ommx >= 3.0.0b3, < 4.0.0",
+  "ommx >= 3.0.0b5, < 4.0.0",
   "mip >= 1.17.0, < 2.0.0",
   "cffi >= 1.15.0, < 2.0.0",
 ]

{ommx_python_mip_adapter-3.0.0b3 → ommx_python_mip_adapter-3.0.0b5}/tests/test_adapter.py

@@ -2,13 +2,14 @@ import pytest
 
 from ommx import (
     DecisionVariable,
-    DegreeBound,
     Equality,
+    Function,
     IndicatorConstraint,
     Instance,
     InstanceClassMismatch,
     Kind,
     OneHotConstraint,
+    PolynomialRequirement,
     Sense,
     Sos1Constraint,
 )
@@ -18,7 +19,6 @@ from ommx_python_mip_adapter import OMMXPythonMIPAdapter
 
 def test_declares_linear_mip_input_class() -> None:
     input_class = OMMXPythonMIPAdapter.INPUT_CLASS
-    assert input_class is not None
     [clause] = input_class.clauses
 
     assert clause.label == "python-mip-linear-mip"
@@ -27,12 +27,12 @@ def test_declares_linear_mip_input_class() -> None:
         Kind.Integer,
         Kind.Continuous,
     }
-    assert clause.objective_degree_bound == DegreeBound.at_most(1)
-    assert clause.regular_constraint_degree_bounds == {
-        Equality.EqualToZero: DegreeBound.at_most(1),
-        Equality.LessThanOrEqualToZero: DegreeBound.at_most(1),
+    assert clause.objective_polynomial_requirement == PolynomialRequirement.at_most(1)
+    assert clause.regular_constraint_polynomial_requirements == {
+        Equality.EqualToZero: PolynomialRequirement.at_most(1),
+        Equality.LessThanOrEqualToZero: PolynomialRequirement.at_most(1),
     }
-    assert clause.indicator_constraint_degree_bounds == {}
+    assert clause.indicator_body_polynomial_requirements == {}
     assert not clause.allows_one_hot
     assert not clause.allows_sos1
     assert clause.allowed_senses == {Sense.Minimize, Sense.Maximize}
@@ -52,10 +52,8 @@ def test_input_class_accepts_complete_linear_mip_boundary(sense: Sense) -> None:
 
     report = OMMXPythonMIPAdapter.check_applicability(instance)
 
-    assert report.is_applicable
-    assert report.input_membership.matching_clauses == [(0, "python-mip-linear-mip")]
-    assert report.preconditions_checked
-    assert report.precondition_violations == ()
+    assert report.is_member
+    assert report.matching_clauses == [(0, "python-mip-linear-mip")]
 
 
 def test_error_nonlinear_objective():
@@ -71,11 +69,27 @@ def test_error_nonlinear_objective():
     with pytest.raises(AdapterNotApplicableError) as e:
         OMMXPythonMIPAdapter(ommx_instance)
     assert isinstance(
-        e.value.report.input_membership.clause_reports[0].mismatches[0],
+        e.value.report.clause_reports[0].mismatches[0],
         InstanceClassMismatch.ObjectiveDegreeExceedsBound,
     )
 
 
+def test_error_non_polynomial_objective() -> None:
+    x = DecisionVariable.continuous(0)
+    instance = Instance.from_components(
+        decision_variables=[x],
+        objective=abs(Function(x)),
+        constraints={},
+        sense=Sense.Minimize,
+    )
+
+    with pytest.raises(AdapterNotApplicableError) as error:
+        OMMXPythonMIPAdapter(instance)
+
+    [mismatch] = error.value.report.clause_reports[0].mismatches
+    assert isinstance(mismatch, InstanceClassMismatch.ObjectiveFunctionNotPolynomial)
+
+
 def test_error_nonlinear_constraint():
     # Objective function: 0
     # Constraint: 2.3 * x * x = 0
@@ -90,7 +104,7 @@ def test_error_nonlinear_constraint():
     with pytest.raises(AdapterNotApplicableError) as e:
         OMMXPythonMIPAdapter(ommx_instance)
     assert isinstance(
-        e.value.report.input_membership.clause_reports[0].mismatches[0],
+        e.value.report.clause_reports[0].mismatches[0],
         InstanceClassMismatch.RegularConstraintDegreeExceedsBound,
     )
 
@@ -118,7 +132,7 @@ def test_rejects_used_unsupported_variable_kinds(
     with pytest.raises(AdapterNotApplicableError) as e:
         OMMXPythonMIPAdapter(instance)
 
-    mismatch = e.value.report.input_membership.clause_reports[0].mismatches[0]
+    mismatch = e.value.report.clause_reports[0].mismatches[0]
     assert isinstance(mismatch, InstanceClassMismatch.VariableKindNotAllowed)
     assert mismatch.kind == kind
     assert mismatch.variable_ids == {0}
@@ -137,14 +151,14 @@ def test_ignores_unused_unsupported_variable_kind() -> None:
     report = OMMXPythonMIPAdapter.check_applicability(instance)
     adapter = OMMXPythonMIPAdapter(instance)
 
-    assert report.is_applicable
+    assert report.is_member
     assert adapter.instance is instance
     assert [variable.name for variable in adapter.solver_input.vars] == ["0"]
 
 
 def test_rejects_special_constraints_without_mutating_input() -> None:
     x = DecisionVariable.binary(0)
-    y = DecisionVariable.continuous(1)
+    y = DecisionVariable.continuous(1, lower=0, upper=2)
     instance = Instance.from_components(
         decision_variables=[x, y],
         objective=x + y,
@@ -165,13 +179,21 @@ def test_rejects_special_constraints_without_mutating_input() -> None:
     with pytest.raises(AdapterNotApplicableError) as e:
         OMMXPythonMIPAdapter(instance)
 
-    mismatches = e.value.report.input_membership.clause_reports[0].mismatches
+    mismatches = e.value.report.clause_reports[0].mismatches
     mismatch_types = {type(mismatch) for mismatch in mismatches}
     assert InstanceClassMismatch.IndicatorConstraintsNotAllowed in mismatch_types
     assert InstanceClassMismatch.OneHotConstraintsNotAllowed in mismatch_types
     assert InstanceClassMismatch.Sos1ConstraintsNotAllowed in mismatch_types
     assert instance.to_v2_bytes() == before
 
+    with pytest.raises(AdapterNotApplicableError):
+        OMMXPythonMIPAdapter.solve_without_preparation(instance)
+    assert instance.to_v2_bytes() == before
+
+    solution = OMMXPythonMIPAdapter.solve(instance)
+    assert solution.feasible
+    assert instance.to_v2_bytes() == before
+
 
 def test_recommended_preparation_reaches_the_python_mip_input_class() -> None:
     x = DecisionVariable.binary(0)
@@ -192,16 +214,15 @@ def test_recommended_preparation_reaches_the_python_mip_input_class() -> None:
         sos1_constraints={30: Sos1Constraint(variables=[y])},
     )
     input_class = OMMXPythonMIPAdapter.INPUT_CLASS
-    assert input_class is not None
     assert not input_class.contains(instance)
 
     policy = OMMXPythonMIPAdapter.recommended_preparation_policy()
     assert policy.special_constraints is not None
-    assert policy.sense is None
+    assert policy.objective is None
     assert policy.integer_slack is None
     assert policy.integer_encoding is None
     assert policy.fixed_penalty is None
 
     assert instance.prepare(input_class, policy) is None
     assert input_class.contains(instance)
-    assert OMMXPythonMIPAdapter.check_applicability(instance).is_applicable
+    assert OMMXPythonMIPAdapter.check_applicability(instance).is_member

{ommx_python_mip_adapter-3.0.0b3 → ommx_python_mip_adapter-3.0.0b5}/tests/test_integration.py

@@ -1,6 +1,6 @@
 import pytest
 
-from ommx import Instance, DecisionVariable, Solution
+from ommx import DecisionVariable, Instance, Optimality, Sense, Solution
 from ommx.adapter import InfeasibleDetected, UnboundedDetected, NoSolutionReturned
 from ommx.testing import SingleFeasibleLPGenerator, DataType
 
@@ -75,6 +75,40 @@ def test_solution_optimality():
     assert solution.optimality == Solution.OPTIMAL
 
 
+def test_solution_optimality_is_not_transported_through_fixed_penalty():
+    x = DecisionVariable.binary(0)
+    instance = Instance.from_components(
+        decision_variables=[x],
+        objective=x,
+        constraints={7: x == 1},
+        sense=Instance.MINIMIZE,
+    )
+    instance.to_qubo(uniform_penalty_weight=0.0)
+
+    solution = OMMXPythonMIPAdapter.solve(instance)
+
+    assert not solution.feasible
+    assert solution.optimality == Optimality.Unspecified
+
+
+def test_output_objective_omits_active_formulation_dual_values():
+    x = DecisionVariable.continuous(0, lower=0)
+    instance = Instance.from_components(
+        decision_variables=[x],
+        objective=x,
+        constraints={0: x <= 1},
+        sense=Sense.Maximize,
+    )
+    assert instance.convert_active_objective(Sense.Minimize)
+
+    adapter = OMMXPythonMIPAdapter(instance)
+    model = adapter.solver_input
+    model.optimize()
+    solution = adapter.decode(model)
+
+    assert solution.get_dual_variable(0) is None
+
+
 def test_partial_evaluate():
     x = [DecisionVariable.binary(i, name="x", subscripts=[i]) for i in range(3)]
     instance = Instance.from_components(