fuzzy-dl-owl2 1.0.6__py3-none-any.whl → 1.0.7__py3-none-any.whl

fuzzy_dl_owl2/fuzzydl/feature_function.py

@@ -122,26 +122,32 @@ class FeatureFunction:
         self, a: Individual, milp: MILPHelper
     ) -> typing.Optional[Expression]:
         if self.type == FeatureFunctionType.ATOMIC:
+            # Get the filler "b" for feature(a)
             rel_set: list[Relation] = a.role_relations.get(self.feature)
+            assert len(rel_set) > 0
             b: CreatedIndividual = typing.cast(
                 CreatedIndividual, rel_set[0].get_object_individual()
             )
+            # Get the variable xB
             x_b: Variable = milp.get_variable(b)
             return Expression(Term(1.0, x_b))
         elif self.type == FeatureFunctionType.NUMBER:
             return Expression(self.n)
         elif self.type == FeatureFunctionType.PRODUCT:
+            assert len(self.f) == 1
             ex: Expression = self.f[0].to_expression(a, milp)
-            return Expression.multiply_constant(ex, self.n)
+            return ex * self.n
         elif self.type == FeatureFunctionType.SUBTRACTION:
+            assert len(self.f) == 2
             ex1: Expression = self.f[0].to_expression(a, milp)
             ex2: Expression = self.f[1].to_expression(a, milp)
-            return Expression.subtract_expressions(ex1, ex2)
+            return ex1 - ex2
         elif self.type == FeatureFunctionType.SUM:
+            assert len(self.f) >= 1
             ex1: Expression = self.f[0].to_expression(a, milp)
             for i in range(1, len(self.f)):
                 ex2: Expression = self.f[i].to_expression(a, milp)
-                ex1: Expression = Expression.add_expressions(ex1, ex2)
+                ex1 = ex1 + ex2
             return ex1
         return None
 

fuzzy_dl_owl2/fuzzydl/fuzzydl_to_owl2.py

@@ -129,6 +129,8 @@ from pyowl2.individual.named_individual import OWLNamedIndividual
 from pyowl2.literal.literal import OWLLiteral
 from pyowl2.ontology import OWLOntology
 
+from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
+
 
 # @utils.timer_decorator
 class FuzzydlToOwl2:
@@ -149,7 +151,7 @@ class FuzzydlToOwl2:
             self.ontology_iri, OWL1_annotations=True
         )
         self.fuzzyLabel: OWLAnnotationProperty = OWLAnnotationProperty(
-            IRI(self.ontology_iri.namespace, "fuzzyLabel")
+            IRI(self.ontology_iri.namespace, ConfigReader.OWL_ANNOTATION_LABEL)
         )
 
         self.ontology.add_axiom(OWLDeclaration(self.fuzzyLabel))

fuzzy_dl_owl2/fuzzydl/knowledge_base.py

@@ -6435,6 +6435,7 @@ class DatatypeReasoner:
         k: list[float],
         type: InequalityType,
     ) -> None:
+        # Gets fillers bi from every feature fi
         array: set[str] = fun.get_features()
         new_variable: bool = False
         for feature in array:
@@ -6454,21 +6455,28 @@ class DatatypeReasoner:
                 x_fi: Variable = kb.milp.get_variable(
                     ind, bi, feature, VariableType.BINARY
                 )
+                # (a,bi):Fi >= x_{(a,bi):Fi}
                 IndividualHandler.add_relation(
                     ind, feature, bi, DegreeVariable.get_degree(x_fi), kb
                 )
-            x_bi: Variable = (
-                kb.milp.get_variable(bi, VariableType.INTEGER)
-                if t.get_type() == ConcreteFeatureType.INTEGER
-                else kb.milp.get_variable(bi, VariableType.CONTINUOUS)
+            x_bi: Variable = kb.milp.get_variable(
+                bi,
+                (
+                    VariableType.INTEGER
+                    if t.get_type() == ConcreteFeatureType.INTEGER
+                    else VariableType.CONTINUOUS
+                ),
             )
-            if new_variable is not None and ki is not None:
+            if new_variable and ki is not None:
                 kb.restrict_range(x_bi, x_fi, ki[0], ki[1])
+            # xIsC <= xFi
             kb.milp.add_new_constraint(
                 Expression(Term(1.0, x_is_c), Term(-1.0, x_fi)),
                 InequalityType.LESS_THAN,
             )
+            # xF \in {0,1}
             x_fi.set_binary_variable()
+            # xB is a datatype filler
             x_bi.set_datatype_filler_variable()
         DatatypeReasoner.write_feature_equation(ind, fun, x_b, x_is_c, x_f, k, type, kb)
 

fuzzy_dl_owl2/fuzzydl/milp/expression.py

@@ -98,7 +98,7 @@ class Expression:
 
     def add_term(self, term: Term) -> None:
         for idx, t in enumerate(self.terms):
-            if t == term:
+            if t.get_var() == term.get_var():
                 self.terms[idx] = t + term
                 return
         self.terms.append(term)
@@ -169,6 +169,17 @@ class Expression:
     def __truediv__(self, scalar: typing.Union[int, float]) -> typing.Self:
         return self * (1 / scalar)
 
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, value: typing.Self) -> bool:
+        if not isinstance(value, Expression):
+            return False
+        return len(self.terms) == len(value.terms) and all(term in value.terms for term in self.terms)
+
+    def __ne__(self, value: typing.Self) -> bool:
+        return not (self == value)
+
     def __repr__(self) -> str:
         return str(self)
 
@@ -184,5 +195,5 @@ class Expression:
             elif n == -1.0:
                 parts.append(f"- {term.get_var()}")
             else:
-                parts.append(f"{'+ ' if n >= 0 else '- '}{n} {term.get_var()}")
+                parts.append(f"{'+ ' if n >= 0 else '- '}{abs(n)} {term.get_var()}")
         return " ".join(parts)

fuzzy_dl_owl2/fuzzydl/milp/inequation.py

@@ -43,6 +43,18 @@ class Inequation:
         assert self.type == InequalityType.GREATER_THAN
         return ">="
 
+    def is_zero(self) -> bool:
+        return all(term.get_coeff() == 0 for term in self.expr.get_terms()) and self.expr.get_constant() == 0
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, value: typing.Self) -> bool:
+        return self.expr == value.expr and self.type == value.type
+
+    def __ne__(self, value: typing.Self) -> bool:
+        return not (self == value)
+
     def __repr__(self) -> str:
         return str(self)
 

fuzzy_dl_owl2/fuzzydl/milp/milp_helper.py

@@ -2,11 +2,9 @@ from __future__ import annotations
 
 import copy
 import os
+import traceback
 import typing
 
-import gurobipy as gp
-from gurobipy import GRB
-
 from fuzzy_dl_owl2.fuzzydl.assertion.assertion import Assertion
 from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
 from fuzzy_dl_owl2.fuzzydl.concept.interface.has_value_interface import (
@@ -26,7 +24,7 @@ from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
 from fuzzy_dl_owl2.fuzzydl.relation import Relation
 from fuzzy_dl_owl2.fuzzydl.restriction.restriction import Restriction
 from fuzzy_dl_owl2.fuzzydl.util import constants
-from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
+from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader, MILPProvider
 from fuzzy_dl_owl2.fuzzydl.util.constants import (
     ConceptType,
     InequalityType,
@@ -62,8 +60,25 @@ class MILPHelper:
         milp.variables = [v.clone() for v in self.variables]
         return milp
 
-    def optimize(self, objective: Expression) -> Solution:
-        return self.solve_gurobi(objective)
+    def optimize(self, objective: Expression) -> typing.Optional[Solution]:
+        Util.debug(f"Running MILP solver: {ConfigReader.MILP_PROVIDER.name}")
+        if ConfigReader.MILP_PROVIDER == MILPProvider.GUROBI:
+            return self.solve_gurobi(objective)
+        elif ConfigReader.MILP_PROVIDER == MILPProvider.MIP:
+            return self.solve_mip(objective)
+        elif ConfigReader.MILP_PROVIDER in [
+            MILPProvider.PULP,
+            MILPProvider.PULP_GLPK,
+            MILPProvider.PULP_HIGHS,
+            MILPProvider.PULP_CPLEX,
+        ]:
+            return self.solve_pulp(objective)
+        # elif ConfigReader.MILP_PROVIDER == MILPProvider.SCIPY:
+        #     return self.solve_scipy(objective)
+        else:
+            raise ValueError(
+                f"Unsupported MILP provider: {ConfigReader.MILP_PROVIDER.name}"
+            )
 
     @typing.overload
     def print_instance_of_labels(
@@ -592,8 +607,10 @@ class MILPHelper:
         return y
 
     def solve_gurobi(self, objective: Expression) -> typing.Optional[Solution]:
+        import gurobipy as gp
+        from gurobipy import GRB
+
         try:
-            Util.debug("Running MILP solver: Gurobi")
             Util.debug(f"Objective function -> {objective}")
 
             num_binary_vars: int = 0
@@ -616,37 +633,45 @@ class MILPHelper:
             env.start()
 
             model = gp.Model("model", env=env)
-            vars_gurobi: list[gp.Var] = []
+            vars_gurobi: dict[str, gp.Var] = dict()
             show_variable: list[bool] = [False] * size
 
             my_vars: list[Variable] = self.show_vars.get_variables()
 
-            for i in range(size):
-                v: Variable = self.variables[i]
-                v_type: VariableType = v.get_type()
+            var_types: dict[VariableType, str] = {
+                VariableType.BINARY: GRB.BINARY,
+                VariableType.INTEGER: GRB.INTEGER,
+                VariableType.CONTINUOUS: GRB.CONTINUOUS,
+                VariableType.SEMI_CONTINUOUS: GRB.SEMICONT,
+            }
+            var_name_map: dict[str, str] = {
+                str(v): f"x{i}" for i, v in enumerate(self.variables)
+            }
+            inv_var_name_map: dict[str, str] = {v: k for k, v in var_name_map.items()}
+
+            for i, curr_variable in enumerate(self.variables):
+                v_type: VariableType = curr_variable.get_type()
                 ov: float = objective_value[i]
 
                 Util.debug(
                     (
                         f"Variable -- "
-                        f"[{v.get_lower_bound()}, {v.get_upper_bound()}] - "
+                        f"[{curr_variable.get_lower_bound()}, {curr_variable.get_upper_bound()}] - "
                         f"Obj value = {ov} - "
                         f"Var type = {v_type.name} -- "
-                        f"Var = {v}"
+                        f"Var = {curr_variable}"
                     )
                 )
 
-                vars_gurobi.append(
-                    model.addVar(
-                        lb=v.get_lower_bound(),
-                        ub=v.get_upper_bound(),
-                        obj=ov,
-                        vtype=v_type.name,
-                        name=str(v),
-                    )
+                vars_gurobi[var_name_map[str(curr_variable)]] = model.addVar(
+                    lb=curr_variable.get_lower_bound(),
+                    ub=curr_variable.get_upper_bound(),
+                    obj=ov,
+                    vtype=var_types[v_type],
+                    name=var_name_map[str(curr_variable)],
                 )
 
-                if v in my_vars:
+                if curr_variable in my_vars:
                     show_variable[i] = True
 
                 if v_type == VariableType.BINARY:
@@ -663,11 +688,15 @@ class MILPHelper:
             Util.debug(f"# constraints -> {len(self.constraints)}")
             constraint_name: str = "constraint"
             for i, constraint in enumerate(self.constraints):
+                if constraint in self.constraints[:i]:
+                    continue
+                if constraint.is_zero():
+                    continue
+
                 curr_name: str = f"{constraint_name}_{i + 1}"
                 expr: gp.LinExpr = gp.LinExpr()
                 for term in constraint.get_terms():
-                    index: int = self.variables.index(term.get_var())
-                    v: gp.Var = vars_gurobi[index]
+                    v: gp.Var = vars_gurobi[var_name_map[str(term.get_var())]]
                     c: float = term.get_coeff()
                     if c == 0:
                         continue
@@ -684,26 +713,26 @@ class MILPHelper:
                     gp_constraint: gp.Constr = expr >= constraint.get_constant()
 
                 model.addConstr(gp_constraint, curr_name)
-                Util.debug(f"{curr_name}: {gp_constraint}")
+                Util.debug(f"{curr_name}: {constraint}")
 
             model.update()
             model.optimize()
 
-            model.write(os.path.join(constants.RESULTS_PATH, "model.lp"))
-            model.write(os.path.join(constants.RESULTS_PATH, "solution.json"))
+            model.write(os.path.join(constants.RESULTS_PATH, "gurobi_model.lp"))
+            model.write(os.path.join(constants.RESULTS_PATH, "gurobi_solution.json"))
 
             Util.debug(f"Model:")
             sol: Solution = None
-            if model.Status == GRB.INFEASIBLE and ConfigReader.RELAX_MILP:
-                self.__handle_model_infeasibility(model)
+            # if model.Status == GRB.INFEASIBLE and ConfigReader.RELAX_MILP:
+            #     self.__gurobi_handle_model_infeasibility(model)
 
             if model.Status == GRB.INFEASIBLE:
                 sol = Solution(False)
             else:
                 for i in range(size):
                     if ConfigReader.DEBUG_PRINT or show_variable[i]:
-                        name: str = vars_gurobi[i].VarName
-                        value: float = round(vars_gurobi[i].X, 6)
+                        name: str = self.variables[i].name
+                        value: float = round(vars_gurobi[var_name_map[name]].X, 6)
                         if self.PRINT_VARIABLES:
                             Util.debug(f"{name} = {value}")
                         if self.PRINT_LABELS:
@@ -729,29 +758,640 @@ class MILPHelper:
             Util.error(f"Error code: {e.errno}. {e.message}")
             return None
 
-    def __handle_model_infeasibility(self, model: gp.Model) -> None:
-        model.computeIIS()
-        # Print out the IIS constraints and variables
-        Util.debug("The following constraints and variables are in the IIS:")
-        Util.debug("Constraints:")
-        for c in model.getConstrs():
-            assert isinstance(c, gp.Constr)
-            if c.IISConstr:
-                Util.debug(f"\t\t{c.ConstrName}: {model.getRow(c)} {c.Sense} {c.RHS}")
-
-        Util.debug("Variables:")
-        for v in model.getVars():
-            if v.IISLB:
-                Util.debug(f"\t\t{v.VarName} ≥ {v.LB}")
-            if v.IISUB:
-                Util.debug(f"\t\t{v.VarName} ≤ {v.UB}")
-
-        Util.debug("Relaxing the variable bounds:")
-        # relaxing only variable bounds
-        model.feasRelaxS(0, False, True, False)
-        # for relaxing variable bounds and constraint bounds use
-        # model.feasRelaxS(0, False, True, True)
-        model.optimize()
+    # def __gurobi_handle_model_infeasibility(self, model: typing.Any) -> None:
+    #     import gurobipy as gp
+
+    #     model: gp.Model = typing.cast(gp.Model, model)
+    #     model.computeIIS()
+    #     # Print out the IIS constraints and variables
+    #     Util.debug("The following constraints and variables are in the IIS:")
+    #     Util.debug("Constraints:")
+    #     for c in model.getConstrs():
+    #         assert isinstance(c, gp.Constr)
+    #         if c.IISConstr:
+    #             Util.debug(f"\t\t{c.ConstrName}: {model.getRow(c)} {c.Sense} {c.RHS}")
+
+    #     Util.debug("Variables:")
+    #     for v in model.getVars():
+    #         if v.IISLB:
+    #             Util.debug(f"\t\t{v.VarName} ≥ {v.LB}")
+    #         if v.IISUB:
+    #             Util.debug(f"\t\t{v.VarName} ≤ {v.UB}")
+
+    #     Util.debug("Relaxing the variable bounds:")
+    #     # relaxing only variable bounds
+    #     model.feasRelaxS(0, False, True, False)
+    #     # for relaxing variable bounds and constraint bounds use
+    #     # model.feasRelaxS(0, False, True, True)
+    #     model.optimize()
+
+    def solve_mip(self, objective: Expression) -> typing.Optional[Solution]:
+        import mip
+
+        try:
+            Util.debug(f"Objective function -> {objective}")
+
+            num_binary_vars: int = 0
+            num_free_vars: int = 0
+            num_integer_vars: int = 0
+            num_up_vars: int = 0
+            size: int = len(self.variables)
+            objective_value: list[float] = [0.0] * size
+
+            if objective is not None:
+                for term in objective.get_terms():
+                    index = self.variables.index(term.get_var())
+                    objective_value[index] += term.get_coeff()
+
+            model: mip.Model = mip.Model(
+                name="FuzzyDL", sense=mip.MINIMIZE, solver_name=mip.CBC
+            )
+            model.verbose = 0
+            model.infeas_tol = 1e-9
+            model.integer_tol = 1e-9
+            model.max_mip_gap = ConfigReader.EPSILON
+            model.emphasis = mip.SearchEmphasis.OPTIMALITY
+            model.opt_tol = 0
+            model.preprocess = 1
+
+            if ConfigReader.DEBUG_PRINT:
+                model.verbose = 1
+
+            vars_mip: dict[str, mip.Var] = dict()
+            show_variable: list[bool] = [False] * size
+
+            my_vars: list[Variable] = self.show_vars.get_variables()
+            var_types: dict[VariableType, str] = {
+                VariableType.BINARY: mip.BINARY,
+                VariableType.INTEGER: mip.INTEGER,
+                VariableType.CONTINUOUS: mip.CONTINUOUS,
+                VariableType.SEMI_CONTINUOUS: mip.CONTINUOUS,
+            }
+            var_name_map: dict[str, str] = {
+                str(v): f"x{i}" for i, v in enumerate(self.variables)
+            }
+            inv_var_name_map: dict[str, str] = {v: k for k, v in var_name_map.items()}
+
+            for i, curr_variable in enumerate(self.variables):
+                v_type: VariableType = curr_variable.get_type()
+                ov: float = objective_value[i]
+
+                Util.debug(
+                    (
+                        f"Variable -- "
+                        f"[{curr_variable.get_lower_bound()}, {curr_variable.get_upper_bound()}] - "
+                        f"Obj value = {ov} - "
+                        f"Var type = {v_type.name} -- "
+                        f"Var = {curr_variable}"
+                    )
+                )
+
+                vars_mip[var_name_map[str(curr_variable)]] = model.add_var(
+                    name=var_name_map[str(curr_variable)],
+                    var_type=var_types[v_type],
+                    lb=curr_variable.get_lower_bound(),
+                    ub=curr_variable.get_upper_bound(),
+                    obj=ov,
+                )
+
+                if curr_variable in my_vars:
+                    show_variable[i] = True
+
+                if v_type == VariableType.BINARY:
+                    num_binary_vars += 1
+                elif v_type == VariableType.CONTINUOUS:
+                    num_free_vars += 1
+                elif v_type == VariableType.INTEGER:
+                    num_integer_vars += 1
+                elif v_type == VariableType.SEMI_CONTINUOUS:
+                    num_up_vars += 1
+
+            Util.debug(f"# constraints -> {len(self.constraints)}")
+            constraint_name: str = "constraint"
+            for i, constraint in enumerate(self.constraints):
+                if constraint in self.constraints[:i]:
+                    continue
+                if constraint.is_zero():
+                    continue
+                curr_name: str = f"{constraint_name}_{i + 1}"
+                expr: mip.LinExpr = mip.xsum(
+                    term.get_coeff() * vars_mip[var_name_map[str(term.get_var())]]
+                    for term in constraint.get_terms()
+                )
+
+                if constraint.get_type() == InequalityType.EQUAL:
+                    gp_constraint: mip.Constr = expr == constraint.get_constant()
+                elif constraint.get_type() == InequalityType.LESS_THAN:
+                    gp_constraint: mip.Constr = expr <= constraint.get_constant()
+                elif constraint.get_type() == InequalityType.GREATER_THAN:
+                    gp_constraint: mip.Constr = expr >= constraint.get_constant()
+
+                model.add_constr(gp_constraint, curr_name)
+                Util.debug(f"{curr_name}: {constraint}")
+
+            model.objective = mip.xsum(
+                ov * vars_mip[var_name_map[str(self.variables[i])]]
+                for i, ov in enumerate(objective_value)
+                if ov != 0
+            )
+
+            # model.optimize(relax=ConfigReader.RELAX_MILP)
+            model.optimize()
+
+            model.write(os.path.join(constants.RESULTS_PATH, "mip_model.lp"))
+
+            Util.debug(f"Model:")
+            sol: Solution = None
+            if model.status == mip.OptimizationStatus.INFEASIBLE:
+                sol = Solution(False)
+            else:
+                model.write(os.path.join(constants.RESULTS_PATH, "mip_solution.sol"))
+                for i in range(size):
+                    if ConfigReader.DEBUG_PRINT or show_variable[i]:
+                        name: str = self.variables[i].name
+                        value: float = round(vars_mip[var_name_map[name]].x, 6)
+                        if self.PRINT_VARIABLES:
+                            Util.debug(f"{name} = {value}")
+                        if self.PRINT_LABELS:
+                            self.print_instance_of_labels(name, value)
+                result: float = Util.round(abs(model.objective_value))
+                sol = Solution(result)
+
+            Util.debug(
+                f"{constants.STAR_SEPARATOR}Statistics{constants.STAR_SEPARATOR}"
+            )
+            Util.debug("MILP problem:")
+            Util.debug(f"\t\tSemi continuous variables: {num_up_vars}")
+            Util.debug(f"\t\tBinary variables: {num_binary_vars}")
+            Util.debug(f"\t\tContinuous variables: {num_free_vars}")
+            Util.debug(f"\t\tInteger variables: {num_integer_vars}")
+            Util.debug(f"\t\tTotal variables: {len(self.variables)}")
+            Util.debug(f"\t\tConstraints: {len(self.constraints)}")
+            return sol
+        except Exception as e:
+            Util.error(f"Error: {e} {traceback.format_exc()}")
+            return None
+
+    def solve_pulp(self, objective: Expression) -> typing.Optional[Solution]:
+        import pulp
+
+        try:
+            Util.debug(f"Objective function -> {objective}")
+
+            num_binary_vars: int = 0
+            num_free_vars: int = 0
+            num_integer_vars: int = 0
+            num_up_vars: int = 0
+            size: int = len(self.variables)
+            objective_value: list[float] = [0.0] * size
+            show_variable: list[bool] = [False] * size
+            my_vars: list[Variable] = self.show_vars.get_variables()
+
+            if objective is not None:
+                for term in objective.get_terms():
+                    objective_value[
+                        self.variables.index(term.get_var())
+                    ] += term.get_coeff()
+
+            model = pulp.LpProblem(
+                f"FuzzyDL-{ConfigReader.MILP_PROVIDER.upper()}", pulp.LpMinimize
+            )
+
+            var_types: dict[VariableType, str] = {
+                VariableType.BINARY: pulp.LpBinary,
+                VariableType.INTEGER: pulp.LpInteger,
+                VariableType.CONTINUOUS: pulp.LpContinuous,
+                VariableType.SEMI_CONTINUOUS: pulp.LpContinuous,
+            }
+
+            vars_pulp: dict[str, pulp.LpVariable] = dict()
+            var_name_map: dict[str, str] = {
+                str(v): f"x{i}" for i, v in enumerate(self.variables)
+            }
+            semicontinuous_var_counter: int = 1
+            semicontinuous_var_name: str = "semic_z"
+            for i, curr_variable in enumerate(self.variables):
+                v_type: VariableType = curr_variable.get_type()
+                Util.debug(
+                    (
+                        f"Variable -- "
+                        f"[{curr_variable.get_lower_bound()}, {curr_variable.get_upper_bound()}] - "
+                        f"Obj value = {objective_value[i]} - "
+                        f"Var type = {v_type.name} -- "
+                        f"Var = {curr_variable}"
+                    )
+                )
+
+                vars_pulp[var_name_map[str(curr_variable)]] = pulp.LpVariable(
+                    name=var_name_map[str(curr_variable)],
+                    lowBound=(
+                        curr_variable.get_lower_bound()
+                        if curr_variable.get_lower_bound() != float("-inf")
+                        else None
+                    ),
+                    upBound=(
+                        curr_variable.get_upper_bound()
+                        if curr_variable.get_upper_bound() != float("inf")
+                        else None
+                    ),
+                    cat=var_types[v_type],
+                )
+
+                if curr_variable in my_vars:
+                    show_variable[i] = True
+
+                if (
+                    v_type == VariableType.SEMI_CONTINUOUS
+                    and ConfigReader.MILP_PROVIDER
+                    in [
+                        MILPProvider.PULP_GLPK,
+                        MILPProvider.PULP_CPLEX,
+                    ]
+                ):
+                    # Semi Continuous variables are not handled by GLPK and HiGHS
+                    # if x in [L, U] u {0} is semi continuous, then add the following constraints
+                    # L * y <= x <= U * y, where y in {0, 1} is a binary variable
+                    bin_var = pulp.LpVariable(
+                        name=f"{semicontinuous_var_name}{semicontinuous_var_counter}",
+                        cat=pulp.LpBinary,
+                    )
+                    constraint_1 = (
+                        vars_pulp[var_name_map[str(curr_variable)]]
+                        >= bin_var * curr_variable.get_lower_bound()
+                    )
+                    constraint_2 = (
+                        vars_pulp[var_name_map[str(curr_variable)]]
+                        <= bin_var * curr_variable.get_upper_bound()
+                    )
+                    if constraint_1 not in model.constraints.values():
+                        model.addConstraint(
+                            constraint_1, name=f"constraint_{bin_var.name}_1"
+                        )
+                    if constraint_2 not in model.constraints.values():
+                        model.addConstraint(
+                            constraint_2, name=f"constraint_{bin_var.name}_2"
+                        )
+                    semicontinuous_var_counter += 1
+                    Util.debug(
+                        (
+                            f"New Variable -- "
+                            f"[{bin_var.lowBound}, {bin_var.upBound}] - "
+                            f"Var type = {bin_var.cat} -- "
+                            f"Var = {bin_var.name}"
+                        )
+                    )
+                    Util.debug(f"New Constraint 1 -- {constraint_1}")
+                    Util.debug(f"New Constraint 2 -- {constraint_2}")
+
+                if v_type == VariableType.BINARY:
+                    num_binary_vars += 1
+                elif v_type == VariableType.CONTINUOUS:
+                    num_free_vars += 1
+                elif v_type == VariableType.INTEGER:
+                    num_integer_vars += 1
+                elif v_type == VariableType.SEMI_CONTINUOUS:
+                    num_up_vars += 1
+
+            Util.debug(f"# constraints -> {len(self.constraints)}")
+            constraint_name: str = "constraint"
+            pulp_sense: dict[InequalityType, int] = {
+                InequalityType.EQUAL: pulp.LpConstraintEQ,
+                InequalityType.LESS_THAN: pulp.LpConstraintLE,
+                InequalityType.GREATER_THAN: pulp.LpConstraintGE,
+            }
+            for i, constraint in enumerate(self.constraints):
+                if constraint in self.constraints[:i]:
+                    continue
+                # ignore zero constraints
+                if constraint.is_zero():
+                    continue
+
+                curr_name: str = f"{constraint_name}_{i + 1}"
+                pulp_expr: pulp.LpAffineExpression = pulp.lpSum(
+                    term.get_coeff() * vars_pulp[var_name_map[str(term.get_var())]]
+                    for term in constraint.get_terms()
+                )
+                pulp_constraint: pulp.LpConstraint = pulp.LpConstraint(
+                    e=pulp_expr,
+                    sense=pulp_sense[constraint.get_type()],
+                    rhs=constraint.get_constant(),
+                )
+
+                # ignore zero constraints of type a * x - a * x
+                if (
+                    len(pulp_constraint) == 1
+                    and list(pulp_constraint.values())[0] == 0
+                    and pulp_constraint.constant == 0
+                ):
+                    continue
+
+                model.addConstraint(pulp_constraint, name=curr_name)
+                Util.debug(f"{curr_name}: {constraint}")
+
+            if ConfigReader.MILP_PROVIDER == MILPProvider.PULP:
+                solver = pulp.PULP_CBC_CMD(
+                    mip=True,
+                    msg=ConfigReader.DEBUG_PRINT,
+                    gapRel=1e-9,
+                    presolve=True,
+                    keepFiles=False,  # ConfigReader.DEBUG_PRINT,
+                    logPath=(
+                        os.path.join(".", "logs", f"pulp_{pulp.PULP_CBC_CMD.name}.log")
+                        if ConfigReader.DEBUG_PRINT
+                        else None
+                    ),
+                    options=[
+                        "--primalTolerance",  # feasibility tolerance
+                        "1e-9",
+                        "--integerTolerance",  # integer feasibility tolerance
+                        "1e-9",
+                        "--ratioGap",  # relative mip gap
+                        str(ConfigReader.EPSILON),
+                        "--allowableGap",  # optimality gap tolerance
+                        "0",
+                        "--preprocess",  # enable preprocessing
+                        "on",
+                    ],
+                )
+            elif ConfigReader.MILP_PROVIDER == MILPProvider.PULP_GLPK:
+                solver = pulp.GLPK_CMD(
+                    mip=True,
+                    msg=ConfigReader.DEBUG_PRINT,
+                    keepFiles=False,  # ConfigReader.DEBUG_PRINT,
+                    options=[
+                        "--presol",  # use presolver (default; assumes --scale and --adv)
+                        "--exact",  # use simplex method based on exact arithmetic
+                        "--xcheck",  # check final basis using exact arithmetic
+                        "--intopt",  # enforce MIP (Mixed Integer Programming)
+                        "--mipgap",
+                        str(
+                            ConfigReader.EPSILON
+                        ),  # no relative gap between primal & best bound
+                    ]
+                    + (
+                        [
+                            "--log",
+                            os.path.join(".", "logs", f"pulp_{pulp.GLPK_CMD.name}.log"),
+                        ]
+                        if ConfigReader.DEBUG_PRINT
+                        else []
+                    ),
+                )
+            elif ConfigReader.MILP_PROVIDER == MILPProvider.PULP_HIGHS:
+                solver = pulp.HiGHS(
+                    mip=True,
+                    msg=ConfigReader.DEBUG_PRINT,
+                    gapRel=1e-6,
+                    log_file=(
+                        os.path.join(".", "logs", f"pulp_{pulp.HiGHS.name}.log")
+                        if ConfigReader.DEBUG_PRINT
+                        else None
+                    ),
+                    primal_feasibility_tolerance=1e-9,
+                    dual_feasibility_tolerance=1e-9,
+                    mip_feasibility_tolerance=1e-9,
+                    presolve="on",
+                    parallel="on",
+                    write_solution_to_file=True,
+                    write_solution_style=1,
+                    solution_file=os.path.join(
+                        constants.RESULTS_PATH, "highs_solution.sol"
+                    ),
+                    write_model_file=os.path.join(
+                        constants.RESULTS_PATH, "highs_model.lp"
+                    ),
+                )
+            elif ConfigReader.MILP_PROVIDER == MILPProvider.PULP_CPLEX:
+                solver = pulp.CPLEX_CMD(
+                    # path="/Applications/CPLEX_Studio2211/cplex/bin/arm64_osx/cplex",
+                    mip=True,
+                    msg=ConfigReader.DEBUG_PRINT,
+                    gapRel=1e-9,
+                    keepFiles=False,  # ConfigReader.DEBUG_PRINT,
+                    logPath=(
+                        os.path.join(".", "logs", f"pulp_{pulp.CPLEX_CMD.name}.log")
+                        if ConfigReader.DEBUG_PRINT
+                        else None
+                    ),
+                )
+
+            model.objective = pulp.lpSum(
+                ov * vars_pulp[var_name_map[str(self.variables[i])]]
+                for i, ov in enumerate(objective_value)
+                if ov != 0
+            )
+            result = model.solve(solver=solver)
+            if ConfigReader.MILP_PROVIDER == MILPProvider.PULP_CPLEX:
+                for file in os.listdir("./"):
+                    if "clone" in file:
+                        os.remove(file)
+
+            Util.debug(f"Model:")
+            sol: Solution = None
+            if result != pulp.LpStatusOptimal:
+                sol = Solution(False)
+            else:
+                var_dict: dict[str, pulp.LpVariable] = model.variablesDict()
+                for i in range(size):
+                    if ConfigReader.DEBUG_PRINT or show_variable[i]:
+                        name: str = self.variables[i].name
+                        value: float = (
+                            round(var_dict[var_name_map[name]].value(), 6)
+                            if var_name_map[name] in var_dict
+                            else 0.0
+                        )
+                        if self.PRINT_VARIABLES:
+                            Util.debug(f"{name} = {value}")
+                        if self.PRINT_LABELS:
+                            self.print_instance_of_labels(name, value)
+                result: float = Util.round(abs(model.objective.value()))
+                sol = Solution(result)
+
+            Util.debug(
+                f"{constants.STAR_SEPARATOR}Statistics{constants.STAR_SEPARATOR}"
+            )
+            Util.debug("MILP problem:")
+            Util.debug(f"\t\tSemi continuous variables: {num_up_vars}")
+            Util.debug(f"\t\tBinary variables: {num_binary_vars}")
+            Util.debug(f"\t\tContinuous variables: {num_free_vars}")
+            Util.debug(f"\t\tInteger variables: {num_integer_vars}")
+            Util.debug(f"\t\tTotal variables: {len(self.variables)}")
+            Util.debug(f"\t\tConstraints: {len(self.constraints)}")
+            return sol
+        except Exception as e:
+            Util.error(f"Error: {e} {traceback.format_exc()}")
+            return None
+
+    # def solve_scipy(self, objective: Expression) -> typing.Optional[Solution]:
+    #     import numpy as np
+    #     from scipy.optimize import milp, OptimizeResult, LinearConstraint, Bounds, linprog, linprog_verbose_callback, show_options
+
+    #     num_binary_vars: int = 0
+    #     num_free_vars: int = 0
+    #     num_integer_vars: int = 0
+    #     num_up_vars: int = 0
+    #     size: int = len(self.variables)
+    #     objective_value: list[float] = [0.0] * size
+    #     show_variable: list[bool] = [False] * size
+    #     my_vars: list[Variable] = self.show_vars.get_variables()
+
+    #     if objective is not None:
+    #         for term in objective.get_terms():
+    #             index = self.variables.index(term.get_var())
+    #             objective_value[index] += term.get_coeff()
+
+    #     var_types: dict[VariableType, str] = {
+    #         VariableType.BINARY: 1,
+    #         VariableType.CONTINUOUS: 0,
+    #         VariableType.INTEGER: 1,
+    #         VariableType.SEMI_CONTINUOUS: 2,
+    #     }
+
+    #     for i, curr_variable in enumerate(self.variables):
+    #         v_type: VariableType = curr_variable.get_type()
+
+    #         Util.debug(
+    #             (
+    #                 f"Variable -- "
+    #                 f"[{curr_variable.get_lower_bound()}, {curr_variable.get_upper_bound()}] - "
+    #                 f"Obj value = {objective_value[i]} - "
+    #                 f"Var type = {v_type.name} -- "
+    #                 f"Var = {curr_variable}"
+    #             )
+    #         )
+
+    #         if curr_variable in my_vars:
+    #             show_variable[i] = True
+
+    #         if v_type == VariableType.BINARY:
+    #             num_binary_vars += 1
+    #         elif v_type == VariableType.CONTINUOUS:
+    #             num_free_vars += 1
+    #         elif v_type == VariableType.INTEGER:
+    #             num_integer_vars += 1
+    #         elif v_type == VariableType.SEMI_CONTINUOUS:
+    #             num_up_vars += 1
+
+    #     Util.debug(f"# constraints -> {len(self.constraints)}")
+    #     constraint_name: str = "constraint"
+    #     matrix_A = np.zeros((len(self.constraints), len(self.variables)))
+    #     inequality_A = np.zeros((len(self.constraints), len(self.variables)))
+    #     equality_A = np.zeros((len(self.constraints), len(self.variables)))
+    #     lb = np.zeros(len(self.constraints))
+    #     ub = np.zeros(len(self.constraints))
+    #     in_ub = np.zeros(len(self.constraints))
+    #     eq_ub = np.zeros(len(self.constraints))
+    #     for i, constraint in enumerate(self.constraints):
+    #         curr_name: str = f"{constraint_name}_{i + 1}"
+    #         row = np.zeros(len(self.variables))
+    #         for term in constraint.get_terms():
+    #             row[self.variables.index(term.get_var())] = term.get_coeff()
+    #         if np.allclose(row, 0):
+    #             continue
+    #         Util.debug(f"{curr_name}: {constraint}")
+    #         matrix_A[i, :] = row
+    #         if constraint.type == InequalityType.EQUAL:
+    #             equality_A[i, :] = row
+    #             eq_ub[i] = constraint.get_constant()
+
+    #             lb[i] = constraint.get_constant()
+    #             ub[i] = constraint.get_constant()
+    #         elif constraint.type == InequalityType.LESS_THAN:
+    #             inequality_A[i, :] = row
+    #             in_ub[i] = constraint.get_constant()
+
+    #             lb[i] = -np.inf
+    #             ub[i] = constraint.get_constant()
+    #         elif constraint.type == InequalityType.GREATER_THAN:
+    #             inequality_A[i, :] = -row
+    #             in_ub[i] = -constraint.get_constant()
+
+    #             lb[i] = constraint.get_constant()
+    #             ub[i] = np.inf
+
+    #     indices = np.all(matrix_A == 0, axis=1)
+    #     matrix_A = np.delete(matrix_A, indices, axis=0)
+    #     lb = np.delete(lb, indices, axis=0)
+    #     ub = np.delete(ub, indices, axis=0)
+
+    #     indices = np.all(inequality_A == 0, axis=1)
+    #     inequality_A = np.delete(inequality_A, indices, axis=0)
+    #     in_ub = np.delete(in_ub, indices, axis=0)
+
+    #     indices = np.all(equality_A == 0, axis=1)
+    #     equality_A = np.delete(equality_A, indices, axis=0)
+    #     eq_ub = np.delete(eq_ub, indices, axis=0)
+
+    #     bounds = Bounds(
+    #         [var.get_lower_bound() for var in self.variables],
+    #         [var.get_upper_bound() for var in self.variables],
+    #         keep_feasible=True,
+    #     )
+    #     integrality = np.array([var_types[var.get_type()] for var in self.variables])
+    #     constraint = LinearConstraint(
+    #         matrix_A, lb, ub, keep_feasible=True
+    #     )
+
+    #     result: OptimizeResult = milp(
+    #         c=np.array(objective_value),
+    #         integrality=integrality,
+    #         constraints=constraint,
+    #         bounds=bounds,
+    #         options={
+    #             "disp": ConfigReader.DEBUG_PRINT,
+    #             "presolve": True,
+    #             "mip_rel_gap": 1e-6,
+    #         },
+    #     )
+
+    #     result: OptimizeResult = linprog(
+    #         c=np.array(objective_value),
+    #         A_ub=inequality_A,
+    #         b_ub=in_ub,
+    #         A_eq=equality_A,
+    #         b_eq=eq_ub,
+    #         method="highs-ipm",
+    #         integrality=integrality,
+    #         bounds=[(var.get_lower_bound(), var.get_upper_bound()) for var in self.variables],
+    #         options={
+    #             "disp": ConfigReader.DEBUG_PRINT,
+    #             "presolve": False,
+    #             "mip_rel_gap": 1e-3,
+    #             "ipm_optimality_tolerance": 1e-5,
+    #         },
+    #         # callback=linprog_verbose_callback if ConfigReader.DEBUG_PRINT else None
+    #     )
+
+    #     Util.debug(f"Model:\n{result}")
+
+    #     sol: Solution = None
+    #     if not result.success:
+    #         sol = Solution(False)
+    #     else:
+    #         for i in range(size):
+    #             if ConfigReader.DEBUG_PRINT or show_variable[i]:
+    #                 name: str = self.variables[i].name
+    #                 value: float = (
+    #                     round(result.x[i], 6)
+    #                 )
+    #                 if self.PRINT_VARIABLES:
+    #                     Util.debug(f"{name} = {value}")
+    #                 if self.PRINT_LABELS:
+    #                     self.print_instance_of_labels(name, value)
+    #         result: float = Util.round(abs(result.fun))
+    #         sol = Solution(result)
+
+    #     Util.debug(
+    #         f"{constants.STAR_SEPARATOR}Statistics{constants.STAR_SEPARATOR}"
+    #     )
+    #     Util.debug("MILP problem:")
+    #     Util.debug(f"\t\tSemi continuous variables: {num_up_vars}")
+    #     Util.debug(f"\t\tBinary variables: {num_binary_vars}")
+    #     Util.debug(f"\t\tContinuous variables: {num_free_vars}")
+    #     Util.debug(f"\t\tInteger variables: {num_integer_vars}")
+    #     Util.debug(f"\t\tTotal variables: {len(self.variables)}")
+    #     Util.debug(f"\t\tConstraints: {len(self.constraints)}")
+    #     return sol
 
     def add_crisp_concept(self, concept_name: str) -> None:
         self.crisp_concepts.add(concept_name)

fuzzy_dl_owl2/fuzzydl/milp/term.py

@@ -64,11 +64,14 @@ class Term:
     def __eq__(self, term: typing.Self) -> bool:
         if not isinstance(term, Term):
             return False
-        return self.var == term.var
+        return self.var == term.var and self.coeff == term.coeff
 
     def __ne__(self, term: typing.Self) -> bool:
         return not (self == term)
 
+    def __hash__(self) -> int:
+        return hash(str(self))
+
     def __repr__(self) -> str:
         return str(self)
 

fuzzy_dl_owl2/fuzzydl/util/config_reader.py

@@ -1,19 +1,42 @@
 from __future__ import annotations
 
 import configparser
+import enum
 import math
 
+from fuzzy_dl_owl2.fuzzydl.util import constants
+
+
+class MILPProvider(enum.StrEnum):
+    GUROBI = enum.auto()
+    MIP = enum.auto()
+    # SCIPY = enum.auto()
+    PULP = enum.auto()
+    PULP_GLPK = enum.auto()
+    PULP_HIGHS = enum.auto()
+    PULP_CPLEX = enum.auto()
+
+    @staticmethod
+    def from_str(value: str) -> MILPProvider:
+        try:
+            return MILPProvider(value.lower())
+        except ValueError:
+            raise ValueError(
+                f"Invalid MILP provider: {value}. Valid options are: {list(MILPProvider)}"
+            )
+
 
 class ConfigReader:
     ANYWHERE_DOUBLE_BLOCKING: bool = True
     ANYWHERE_SIMPLE_BLOCKING: bool = True
-    RELAX_MILP: bool = False
     DEBUG_PRINT: bool = True
     EPSILON: float = 0.001
     MAX_INDIVIDUALS: int = -1
     NUMBER_DIGITS: int = 2
     OPTIMIZATIONS: int = 1
     RULE_ACYCLIC_TBOXES: bool = True
+    OWL_ANNOTATION_LABEL: str = "fuzzyLabel"
+    MILP_PROVIDER: MILPProvider = MILPProvider.GUROBI
 
     @staticmethod
     def load_parameters(config_file: str, args: list[str]) -> None:
@@ -33,13 +56,32 @@ class ConfigReader:
             #         "author": False,
             #     }
 
-            ConfigReader.RELAX_MILP = config.getboolean("DEFAULT", "relaxMilp")
             ConfigReader.DEBUG_PRINT = config.getboolean("DEFAULT", "debugPrint")
             ConfigReader.EPSILON = config.getfloat("DEFAULT", "epsilon")
             ConfigReader.MAX_INDIVIDUALS = config.getint("DEFAULT", "maxIndividuals")
+            ConfigReader.OWL_ANNOTATION_LABEL = config.get(
+                "DEFAULT", "owlAnnotationLabel"
+            )
+            ConfigReader.MILP_PROVIDER = MILPProvider(
+                config.get("DEFAULT", "milpProvider").lower()
+            )
             ConfigReader.NUMBER_DIGITS = int(
                 round(abs(math.log10(ConfigReader.EPSILON) - 1.0))
             )
+            if ConfigReader.MILP_PROVIDER in [
+                MILPProvider.MIP,
+                MILPProvider.PULP,
+            ]:
+                constants.MAXVAL = (1 << 31) - 1
+                constants.MAXVAL2 = constants.MAXVAL * 2
+            elif ConfigReader.MILP_PROVIDER in [
+                MILPProvider.PULP_GLPK,
+                MILPProvider.PULP_HIGHS,
+                MILPProvider.PULP_CPLEX,
+                # MILPProvider.SCIPY,
+            ]:
+                constants.MAXVAL = (1 << 28) - 1
+                constants.MAXVAL2 = constants.MAXVAL * 2
 
             if ConfigReader.DEBUG_PRINT:
                 print(f"Debugging mode = {ConfigReader.DEBUG_PRINT}")

fuzzy_dl_owl2/fuzzydl/util/constants.py

@@ -4,7 +4,6 @@ import re
 import typing
 
 import pyparsing as pp
-from gurobipy import GRB
 
 SEPARATOR: str = "-" * 25
 STAR_SEPARATOR: str = "*" * 25
@@ -239,10 +238,10 @@ class InequalityType(enum.StrEnum):
 
 
 class VariableType(enum.StrEnum):
-    BINARY = GRB.BINARY
-    CONTINUOUS = GRB.CONTINUOUS
-    INTEGER = GRB.INTEGER
-    SEMI_CONTINUOUS = GRB.SEMICONT
+    BINARY = enum.auto()
+    CONTINUOUS = enum.auto()
+    INTEGER = enum.auto()
+    SEMI_CONTINUOUS = enum.auto()
 
     def __repr__(self) -> str:
         return self.name
@@ -421,5 +420,5 @@ class FuzzyLogic(enum.StrEnum):
 
 
 KNOWLEDGE_BASE_SEMANTICS: FuzzyLogic = FuzzyLogic.CLASSICAL
-MAXVAL: float = 2.147483647e12
+MAXVAL: float = ((1 << 31) - 1) * 1000  # 2.147483647e12
 MAXVAL2: float = MAXVAL * 2

fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2.py

@@ -146,6 +146,8 @@ from pyowl2.individual.anonymous_individual import OWLAnonymousIndividual
 from pyowl2.literal.literal import OWLLiteral
 from pyowl2.ontology import OWLOntology
 
+from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
+
 
 class FuzzyOwl2(object):
     POS_INFINITY: float = 10000.0
@@ -174,7 +176,7 @@ class FuzzyOwl2(object):
             self.ontology_iri, self.ontology_path, OWL1_annotations=True
         )
         self.fuzzy_label: OWLAnnotationProperty = OWLAnnotationProperty(
-            IRI(self.ontology_iri.namespace, "fuzzyLabel")
+            IRI(self.ontology_iri.namespace, ConfigReader.OWL_ANNOTATION_LABEL)
         )
         self.ontologies.add(self.ontology)
         # self.ontologies.update(self.manager.getImportsClosure(self.ontology))

{fuzzy_dl_owl2-1.0.6.dist-info → fuzzy_dl_owl2-1.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fuzzy-dl-owl2
-Version: 1.0.6
+Version: 1.0.7
 Summary: A python porting of the Fuzzy Description Language (see https://www.umbertostraccia.it/cs/software/fuzzyDL/fuzzyDL.html) and the Fuzzy OWL 2 framework (see https://www.umbertostraccia.it/cs/software/FuzzyOWL/index.html).
 License: CC-BY-SA-4.0
 Author: Giuseppe Filippone
@@ -11,12 +11,12 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: gurobipy (>=12.0.0,<13.0.0)
 Requires-Dist: networkx (>=3.3,<4.0)
 Requires-Dist: owlready2 (>=0.47,<0.48)
 Requires-Dist: pyowl2 (>=1.0.2,<2.0.0)
 Requires-Dist: pyparsing (>=3.2.3,<4.0.0)
 Requires-Dist: rdflib (>=7.1.4,<8.0.0)
+Requires-Dist: setuptools (>=80.8.0,<81.0.0)
 Requires-Dist: sortedcontainers (>=2.4.0,<3.0.0)
 Requires-Dist: trycast (>=1.2.0,<2.0.0)
 Project-URL: Repository, https://github.com/giuseppefilippone/fuzzy_dl_owl2
@@ -78,17 +78,85 @@ The file `CONFIG.ini` is structured as follows:
 ```text
 [DEFAULT]
 debugPrint = False
-relaxMilp = False
 epsilon = 0.001
 maxIndividuals = -1
+owlAnnotationLabel = fuzzyLabel
+milpProvider = mip
 ```
 
 | Configuration Variable | Description                       |
 |----------------------|-----------------------------------|
 | debugPrint        | Enable/disable debugging          |
-| relaxMilp      | Enable/disable MILP constraint relaxation. Important: The solution may be wrong by enabling this flag |
 | epsilon | Define the precision of the solution. For instance, epsilon = 0.001 means that the solution will be calculated with an accuracy to the third decimal place |
 | maxIndividuals | Define the maximal number of individuals to handle. The value -1 indicate that there is no maximum |
+| owlAnnotationLabel | Define the Annotation label used to build the Fuzzy OWL 2 RDF/XML ontology |
+| milpProvider | Define the MILP provider used by the reasoner. The supported providers are listed below. |
+
+Supported MILP Providers:
+| Provider | milpProvider |
+|--------------|----------------------|
+| Gurobi | gurobi |
+| CPLEX | pulp_cplex |
+| CBC | pulp |
+| GLPK | pulp_glpk |
+| HiGHS | pulp_highs |
+| MIP | mip |
+
+⸻
+
+# MILP Provider Usage and Configuration
+
+## GUROBI
+
+- Install [gurobipy](https://pypi.org/project/gurobipy/):
+```python
+pip install gurobipy==12.0.0
+```
+- Download the GUROBI license from their [website](https://www.gurobi.com/solutions/licensing/).
+- Add Gurobi to the PATH
+
+## MIP
+
+- Install python [MIP](https://www.python-mip.com/):
+```python
+pip install mip==1.16rc0
+```
+
+## GLPK
+
+- Install [GLPK](https://www.gnu.org/software/glpk/) v5.0 and [GMP](https://gmplib.org/) v6.3.0
+- Install python [pulp](https://github.com/coin-or/PuLP?tab=readme-ov-file):
+```python
+pip install pulp==3.2.1
+```
+- Add GLPK to the PATH
+
+## CBC
+
+- Install [CBC](https://github.com/coin-or/Cbc)
+- Install python [pulp](https://github.com/coin-or/PuLP?tab=readme-ov-file):
+```python
+pip install pulp==3.2.1
+```
+- Add CBC to the PATH
+
+## CPLEX
+
+- Install [CPLEX](https://www.ibm.com/it-it/products/ilog-cplex-optimization-studio) v22.11
+- Install python [pulp](https://github.com/coin-or/PuLP?tab=readme-ov-file):
+```python
+pip install pulp==3.2.1
+```
+- Add CPLEX to the PATH
+
+## HiGHS
+
+- Install [HiGHS](https://ergo-code.github.io/HiGHS/dev/interfaces/cpp/) v1.10.0
+- Install python [pulp](https://github.com/coin-or/PuLP?tab=readme-ov-file):
+```python
+pip install pulp==3.2.1
+```
+- Add HiGHS to the PATH
 
 ⸻
 

{fuzzy_dl_owl2-1.0.6.dist-info → fuzzy_dl_owl2-1.0.7.dist-info}/RECORD

@@ -61,22 +61,22 @@ fuzzy_dl_owl2/fuzzydl/domain_axiom.py,sha256=qPjeqmA7zQt6VT-bLtT82F74fiORPegQytd
 fuzzy_dl_owl2/fuzzydl/exception/__init__.py,sha256=IoYY5IQoU4UYyoB-dFOVLZyDvJN20kgZVBqWkF6J30w,135
 fuzzy_dl_owl2/fuzzydl/exception/fuzzy_ontology_exception.py,sha256=eH1ybBCx1QoZaf8PLCq1rC_3tiBRA-gKCwECTcUUuro,122
 fuzzy_dl_owl2/fuzzydl/exception/inconsistent_ontology_exception.py,sha256=ez0RQN4KGlNRcfB7IXfPz3bM86CFLl6zo-RRTBRpa_o,129
-fuzzy_dl_owl2/fuzzydl/feature_function.py,sha256=KSQvCSYfJK5N6FFfDlyS1Y7UPHSYZNXzdYYZMWzXF8U,6399
-fuzzy_dl_owl2/fuzzydl/fuzzydl_to_owl2.py,sha256=aqFuf7xH7_5fJL57RlLhN2tzpQEX8i6LzlTmKRAkZak,53023
+fuzzy_dl_owl2/fuzzydl/feature_function.py,sha256=Ipfd_UuKWKqCp8jdyV3Hxia0l3yj8jjNu-kOGQ7qf3Y,6525
+fuzzy_dl_owl2/fuzzydl/fuzzydl_to_owl2.py,sha256=VjmHtokMAE0jC9jI8WjGeiCTQ-A8YmmUH14FEVTyrDU,53111
 fuzzy_dl_owl2/fuzzydl/general_concept_inclusion.py,sha256=Noom35WAeJosPrliGd9_gvEtcK4BthazsSuZH-cxfyU,2380
 fuzzy_dl_owl2/fuzzydl/individual/__init__.py,sha256=zBCa24kE2nv08VgtphjLshpbGNEARUJgCdtyv9r6JGc,110
 fuzzy_dl_owl2/fuzzydl/individual/created_individual.py,sha256=HOo_UXjPPPtm7B0a7k90kE1veuR9gOCK5hp2f_aaJnY,7653
 fuzzy_dl_owl2/fuzzydl/individual/individual.py,sha256=FgtOmJwkPUKIOr-o8a1NqHepL-sN5fGe314e895DHYg,3846
 fuzzy_dl_owl2/fuzzydl/individual/representative_individual.py,sha256=C5ZG43Xy0Iz71S5IYPzaBGeT-fWIqQGpg85DPgU1NjM,1070
-fuzzy_dl_owl2/fuzzydl/knowledge_base.py,sha256=MmzpyLpiAkxZBbRJP2IywuS0A87lmv26lYv9RyTxN74,385654
+fuzzy_dl_owl2/fuzzydl/knowledge_base.py,sha256=ve0NYDz1b2Up-ZoTzJO-JltyupMFhyy9meIzMvFIt-I,385863
 fuzzy_dl_owl2/fuzzydl/label.py,sha256=KD39rTIlg0XhDJSVqNC6t0Pu60MVfO8xNGSjrcJFtD0,1023
 fuzzy_dl_owl2/fuzzydl/milp/__init__.py,sha256=g2oFT2Ge8W5Li2kP2CJjpjJ1a0PRI2vDoDdzYDsEtDY,246
-fuzzy_dl_owl2/fuzzydl/milp/expression.py,sha256=j_77ddxfktzjRCRmjvew6zr5Rj8pmMfL2N0PvdpGfL4,6197
-fuzzy_dl_owl2/fuzzydl/milp/inequation.py,sha256=dQhRXj7xQm6021bUV58WPNnxH7EqsonPrWOCoCBqR5A,1631
-fuzzy_dl_owl2/fuzzydl/milp/milp_helper.py,sha256=Dfeh7eGknCez6Ku5m7wdxsdqJkSq4vtgfH93xth7ILM,30388
+fuzzy_dl_owl2/fuzzydl/milp/expression.py,sha256=HTCSk_EGTO7ATIQuV65mKa06eY433PVs_8jyw4kbELg,6596
+fuzzy_dl_owl2/fuzzydl/milp/inequation.py,sha256=4agNmrrT8K1uEnm553nD8OPwVY4l4rF3Dxw-_PBj5lw,2040
+fuzzy_dl_owl2/fuzzydl/milp/milp_helper.py,sha256=aghOzlFqkZUK53lIPXIeDbwgt2E6cCy805bN35DGq0E,58324
 fuzzy_dl_owl2/fuzzydl/milp/show_variables_helper.py,sha256=7y-lfhoERoE8qNSMr0cq_-Ezo46BGsNszp44YSVWA2A,5754
 fuzzy_dl_owl2/fuzzydl/milp/solution.py,sha256=suoE1F2XORwzP4pNm-6Ivf6eK5Z98KFxFUdarh1CjQk,1210
-fuzzy_dl_owl2/fuzzydl/milp/term.py,sha256=IDnmmpXIgewY9NkPwM1YFzkcp21umo4ZoPBzAhGdn8Q,2202
+fuzzy_dl_owl2/fuzzydl/milp/term.py,sha256=JIRO3rrMz1e6I3g0tElFbwXyOxtiy8L7Wh6EisQfSuM,2294
 fuzzy_dl_owl2/fuzzydl/milp/variable.py,sha256=_qqLZpOkXCaeyguQQWLIQvTPzyPaMNSpPIAL4T0A9C8,2725
 fuzzy_dl_owl2/fuzzydl/modifier/__init__.py,sha256=mgJml-9PVs566EYpwBxfmmiw8oPXiSgJRUyIX9hiSNA,126
 fuzzy_dl_owl2/fuzzydl/modifier/linear_modifier.py,sha256=Rn6q4ytIdTiCI-TRZIK5qjWSA4K3q78fYSrYxlQklVc,2022
@@ -118,12 +118,12 @@ fuzzy_dl_owl2/fuzzydl/restriction/has_value_restriction.py,sha256=DL-50TlD289OXV
 fuzzy_dl_owl2/fuzzydl/restriction/restriction.py,sha256=SyeFvaJeKcTe750eAbLoAVYkWTK_UjdqWr2Lw8OF1S0,948
 fuzzy_dl_owl2/fuzzydl/role_parent_with_degree.py,sha256=1J5dtlVbiascxHBwAJ7uc97IHnJke9RWqxq5rgrrkoA,282
 fuzzy_dl_owl2/fuzzydl/util/__init__.py,sha256=3GufSMUuWGISGukXM5T5ZGA0BC1WX-5eLFSuttVYueU,109
-fuzzy_dl_owl2/fuzzydl/util/config_reader.py,sha256=8kyrfK-wQaiGrKfrLsiVr77jg1NRaviGniWOtQwrZRU,1797
-fuzzy_dl_owl2/fuzzydl/util/constants.py,sha256=_BM9maPkVPzz-GjWjVHjPEtNOA72c5R4qjP9w-2bAdQ,12817
+fuzzy_dl_owl2/fuzzydl/util/config_reader.py,sha256=dh2Xa1sYVlKavbkKShHkxzA0ieLoQOV1JmzkOvIIVMI,3174
+fuzzy_dl_owl2/fuzzydl/util/constants.py,sha256=tZKlMOZlZD9iKgaLv8NIId5WK04JuFg6FuXyA7zEe8E,12815
 fuzzy_dl_owl2/fuzzydl/util/util.py,sha256=5COC79TAJz8fNrRzXLbNpAT9rLd_0KrRI1OU-hob3oU,1903
 fuzzy_dl_owl2/fuzzydl/util/utils.py,sha256=TPVLEL9NJXgReuxEIOTEOVYqojSymg_-kyrLETXnYdo,2344
 fuzzy_dl_owl2/fuzzyowl2/__init__.py,sha256=C44P0-Sn35FQdVMqYLzeDWa5qPmokbcs8GPiD_zQaSg,153
-fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2.py,sha256=5nMIJfNxes5OXyGJxFkdG5VIueOUaK-5TNN4KMLeESk,71603
+fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2.py,sha256=TYnSLXK-oR7jsOEFR46WryA0gKVBLbBI0_3Cd-dHUuU,71691
 fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2_to_fuzzydl.py,sha256=egspxTzY4kNvhsQLP0AAaqJgFUqyO6VJuXLLOej06PA,36994
 fuzzy_dl_owl2/fuzzyowl2/owl_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fuzzy_dl_owl2/fuzzyowl2/owl_types/choquet_concept.py,sha256=ymnyNfvkvWA3y2UMXyPviD0U98vJ6jrX6zddj09SUoI,671
@@ -158,7 +158,7 @@ fuzzy_dl_owl2/fuzzyowl2/parser/owl2_xml_parser.py,sha256=qbx6SsrYUdDOn1-qClq-0EC
 fuzzy_dl_owl2/fuzzyowl2/util/__init__.py,sha256=4qG4CwkdYoT0vh3uX9N8DlmXh4QfKimVUqR4h2DR8Gg,50
 fuzzy_dl_owl2/fuzzyowl2/util/constants.py,sha256=Oev5Q-H4mhmdvV3nrp0fZKZx8jpo9beXjJwm0dfDUSc,6970
 fuzzy_dl_owl2/fuzzyowl2/util/fuzzy_xml.py,sha256=iYAodtBkZYt3cOvMBA0VEMOU87ljb-06_aUfH14gvwE,3416
-fuzzy_dl_owl2-1.0.6.dist-info/LICENSE,sha256=er4Z7Ju3OzYUG5mbhh0krYVegIuv4PgehMzihVb2wpc,20131
-fuzzy_dl_owl2-1.0.6.dist-info/METADATA,sha256=BjS_oE4GrApDHsEvGzus0rGZ6yXtLmf_U3ZmBa9VVe8,13057
-fuzzy_dl_owl2-1.0.6.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-fuzzy_dl_owl2-1.0.6.dist-info/RECORD,,
+fuzzy_dl_owl2-1.0.7.dist-info/LICENSE,sha256=er4Z7Ju3OzYUG5mbhh0krYVegIuv4PgehMzihVb2wpc,20131
+fuzzy_dl_owl2-1.0.7.dist-info/METADATA,sha256=NM2tQrq1p7MNs5PbRMBl4ECC1qYG1EC-eqmWjTGHyNk,14681
+fuzzy_dl_owl2-1.0.7.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+fuzzy_dl_owl2-1.0.7.dist-info/RECORD,,