fuzzy-dl-owl2 1.0.0__py3-none-any.whl

fuzzy_dl_owl2/fuzzydl/query/defuzzify/mom_defuzzify_query.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import traceback
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.degree.degree_numeric import DegreeNumeric
+from fuzzy_dl_owl2.fuzzydl.exception.fuzzy_ontology_exception import (
+    FuzzyOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.individual.created_individual import CreatedIndividual
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
+from fuzzy_dl_owl2.fuzzydl.milp.term import Term
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+from fuzzy_dl_owl2.fuzzydl.query.defuzzify.defuzzify_query import DefuzzifyQuery
+from fuzzy_dl_owl2.fuzzydl.query.max.max_satisfiable_query import MaxSatisfiableQuery
+from fuzzy_dl_owl2.fuzzydl.relation import Relation
+from fuzzy_dl_owl2.fuzzydl.util.util import Util
+
+
+class MomDefuzzifyQuery(DefuzzifyQuery):
+
+    def __init__(self, c: Concept, ind: Individual, feature_name: str) -> None:
+        super().__init__(c, ind, feature_name)
+
+    def preprocess(self, kb: KnowledgeBase) -> None:
+        pass
+
+    def solve(self, kb: KnowledgeBase) -> Solution:
+        try:
+            kb.solve_abox()
+            cloned: KnowledgeBase = kb.clone()
+            cloned.set_dynamic_blocking()
+            s: Solution = MaxSatisfiableQuery(self.conc, self.a).solve(cloned)
+            if not s.is_consistent_kb():
+                return s
+            d: float = s.get_solution()
+            cloned: KnowledgeBase = kb.clone()
+            ind: Individual = cloned.individuals.get(str(self.a))
+            cloned.set_dynamic_blocking()
+            cloned.add_assertion(self.a, self.conc, DegreeNumeric.get_degree(d))
+            cloned.solve_assertions()
+            if self.f_name not in ind.role_relations:
+                Util.warning("Warning: Problem in defuzzification. Answer is 0.")
+                return None
+        except InconsistentOntologyException:
+            return Solution(False)
+
+        rel_set: list[Relation] = ind.role_relations.get(self.f_name)
+        b: CreatedIndividual = typing.cast(
+            CreatedIndividual, rel_set[0].get_object_individual()
+        )
+        q: Variable = cloned.milp.get_variable(b)
+        if q is None:
+            Util.warning("Warning: Problem in defuzzification. Answer is 0.")
+            return None
+
+        try:
+            self.ob_expr: Expression = Expression(Term(-1.0, q))
+            sol1: Solution = cloned.optimize(self.obj_expr)
+            if sol1.get_solution() < 0.0:
+                sol1 = Solution(-sol1.get_solution())
+            self.obj_expr: Expression = Expression(Term(1.0, q))
+            sol2: Solution = cloned.optimize(self.obj_expr)
+            if sol2.get_solution() < 0.0:
+                sol2 = Solution(-sol2.get_solution())
+            if sol1.is_consistent_kb() and sol2.is_consistent_kb():
+                value = (sol1.get_solution() + sol2.get_solution()) / 2.0
+                kb.milp.print_instance_of_labels(self.f_name, str(self.a), value)
+                return Solution(value)
+            return sol1
+        except FuzzyOntologyException as e:
+            traceback.print_exc()
+        except InconsistentOntologyException as e:
+            traceback.print_exc()
+        return None
+
+    def get_obj_expression(self, variable: Variable) -> Expression:
+        return Expression(Term(-1.0, variable))
+
+    def __str__(self) -> str:
+        return f"Middle of the maxima defuzzification of feature {self.f_name} for instance {self.a} = "

fuzzy_dl_owl2/fuzzydl/query/defuzzify/som_defuzzify_query.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.term import Term
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+from fuzzy_dl_owl2.fuzzydl.query.defuzzify.defuzzify_query import DefuzzifyQuery
+
+
+class SomDefuzzifyQuery(DefuzzifyQuery):
+
+    def __init__(self, c: Concept, ind: Individual, f_name: str) -> None:
+        super().__init__(c, ind, f_name)
+
+    def __str__(self) -> str:
+        return f"Smallest of the maxima defuzzification of feature {self.f_name} for instance {self.a} = "
+
+    def get_obj_expression(self, q: Variable) -> Expression:
+        return Expression(Term(1.0, q))

fuzzy_dl_owl2/fuzzydl/query/instance_query.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from abc import ABC
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.query.query import Query
+from fuzzy_dl_owl2.fuzzydl.util.util import Util
+
+
+class InstanceQuery(Query, ABC):
+    def __init__(self, concept: Concept, individual: Individual) -> None:
+        if concept.is_concrete():
+            Util.error(f"Error: {concept} cannot be a concrete concept.")
+
+        self.conc: Concept = concept
+        self.ind: Individual = individual
+        self.obj_expr: Expression = None

fuzzy_dl_owl2/fuzzydl/query/kb_satisfiable_query.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
+from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
+from fuzzy_dl_owl2.fuzzydl.query.query import Query
+
+
+class KbSatisfiableQuery(Query):
+
+    def preprocess(self, kb: KnowledgeBase) -> None:
+        pass
+
+    def solve(self, kb: KnowledgeBase) -> Solution:
+        try:
+            return Solution(1.0) if self.is_consistent_kb(kb) else Solution(False)
+        except InconsistentOntologyException:
+            return Solution(False)
+
+    def is_consistent_kb(self, kb: KnowledgeBase) -> bool:
+        kb.solve_abox()
+        cloned: KnowledgeBase = kb.clone()
+        if len(cloned.individuals) == 0:
+            cloned.get_new_individual()
+            cloned.solve_assertions()
+        sol: Solution = cloned.optimize(None)
+        return sol is not None and sol.is_consistent_kb()
+
+    def __str__(self) -> str:
+        return "Is KnowledgeBase satisfiable? = "

fuzzy_dl_owl2/fuzzydl/query/max/__init__.py

@@ -0,0 +1,5 @@
+from .max_instance_query import MaxInstanceQuery
+from .max_query import MaxQuery
+from .max_related_query import MaxRelatedQuery
+from .max_satisfiable_query import MaxSatisfiableQuery
+from .max_subsumes_query import MaxSubsumesQuery

fuzzy_dl_owl2/fuzzydl/query/max/max_instance_query.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.degree.degree_variable import DegreeVariable
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
+from fuzzy_dl_owl2.fuzzydl.milp.term import Term
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+from fuzzy_dl_owl2.fuzzydl.query.instance_query import InstanceQuery
+
+
+class MaxInstanceQuery(InstanceQuery):
+    def __init__(self, concept: Concept, individual: Individual) -> None:
+        super().__init__(concept, individual)
+
+    def preprocess(self, kb: KnowledgeBase) -> None:
+        q: Variable = kb.milp.get_variable(self.ind, self.conc)
+        kb.old_01_variables += 1
+        self.obj_expr: Expression = Expression(Term(-1.0, q))
+
+        if "(all " in str(self.conc) or "(not (b-some " in str(self.conc):
+            kb.set_dynamic_blocking()
+
+        kb.add_assertion(self.ind, self.conc, DegreeVariable.get_degree(q))
+        kb.solve_assertions()
+
+    def solve(self, kb: KnowledgeBase) -> Solution:
+        try:
+            self.set_initial_time()
+            kb.solve_abox()
+            cloned: KnowledgeBase = kb.clone()
+            self.preprocess(cloned)
+            sol: Solution = cloned.optimize(self.obj_expr)
+            self.set_total_time()
+            return sol
+        except InconsistentOntologyException:
+            return Solution(False)
+
+    def __str__(self) -> str:
+        return f"Is {self.ind} instance of {self.conc} ? <= "

fuzzy_dl_owl2/fuzzydl/query/max/max_query.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
+from fuzzy_dl_owl2.fuzzydl.query.query import Query
+
+
+class MaxQuery(Query):
+    def __init__(self, expr: Expression) -> None:
+        self.obj_expr: Expression = Expression.negate_expression(expr)
+
+    def preprocess(self, kb: KnowledgeBase) -> None:
+        pass
+
+    def solve(self, kb: KnowledgeBase) -> Solution:
+        try:
+            self.set_initial_time()
+            kb.solve_abox()
+            cloned: KnowledgeBase = kb.clone()
+            sol: Solution = cloned.optimize(self.obj_expr)
+            self.set_total_time()
+            return sol
+        except InconsistentOntologyException:
+            return Solution(False)
+
+    def __str__(self) -> str:
+        return f"{self.obj_expr} <= "

fuzzy_dl_owl2/fuzzydl/query/max/max_related_query.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.has_value_concept import HasValueConcept
+from fuzzy_dl_owl2.fuzzydl.degree.degree_variable import DegreeVariable
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
+from fuzzy_dl_owl2.fuzzydl.milp.term import Term
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+from fuzzy_dl_owl2.fuzzydl.query.related_query import RelatedQuery
+
+
+class MaxRelatedQuery(RelatedQuery):
+    def __init__(self, a: Individual, b: Individual, role_name: str) -> None:
+        self.ind1: Individual = a
+        self.ind2: Individual = b
+        self.role: str = role_name
+
+    def preprocess(self, kb: KnowledgeBase) -> None:
+        conc: Concept = HasValueConcept(self.role, self.ind2)
+        q: Variable = kb.milp.get_variable(self.ind1, conc)
+        kb.add_assertion(self.ind1, conc, DegreeVariable.get_degree(q))
+        kb.old_01_variables += 1
+        self.obj_expr: Expression = Expression(Term(-1.0, q))
+        kb.solve_assertions()
+
+    def solve(self, kb: KnowledgeBase) -> Solution:
+        try:
+            self.set_initial_time()
+            kb.solve_abox()
+            cloned: KnowledgeBase = kb.clone()
+            self.preprocess(cloned)
+            sol: Solution = cloned.optimize(self.obj_expr)
+            self.set_total_time()
+            return sol
+        except InconsistentOntologyException:
+            return Solution(False)
+
+    def __str__(self) -> str:
+        return f"Is {self.ind1} related to {self.ind2} through {self.role} ? <= "

fuzzy_dl_owl2/fuzzydl/query/max/max_satisfiable_query.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.degree.degree_variable import DegreeVariable
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
+from fuzzy_dl_owl2.fuzzydl.milp.term import Term
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+from fuzzy_dl_owl2.fuzzydl.query.satisfiable_query import SatisfiableQuery
+from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
+
+
+class MaxSatisfiableQuery(SatisfiableQuery):
+
+    @typing.overload
+    def __init__(self, c: Concept) -> None: ...
+
+    @typing.overload
+    def __init__(self, c: Concept, a: Individual) -> None: ...
+
+    def __init__(self, *args) -> None:
+        assert len(args) in [1, 2]
+        assert isinstance(args[0], Concept)
+        if len(args) == 1:
+            self.__max_sat_query_init_1(*args)
+        else:
+            assert args[1] is None or isinstance(args[1], Individual)
+            self.__max_sat_query_init_2(*args)
+
+    def __max_sat_query_init_1(self, c: Concept) -> None:
+        super().__init__(c)
+
+    def __max_sat_query_init_2(self, c: Concept, a: Individual) -> None:
+        super().__init__(c, a)
+
+    def preprocess(self, kb: KnowledgeBase) -> None:
+        if "(all " in str(self.conc) or "(not (b-some " in str(self.conc):
+            kb.set_dynamic_blocking()
+        q: Variable = kb.milp.get_variable(self.ind, self.conc)
+        kb.old_01_variables += 1
+        self.obj_expr: Expression = Expression(Term(-1.0, q))
+        kb.add_assertion(self.ind, self.conc, DegreeVariable.get_degree(q))
+        kb.solve_assertions()
+
+    def solve(self, kb: KnowledgeBase) -> Solution:
+        try:
+            self.set_initial_time()
+            use_abox = self.ind is not None or ConfigReader.OPTIMIZATIONS == 0
+            cloned: KnowledgeBase = kb.clone() if use_abox else kb.clone_without_abox()
+            if self.ind is None:
+                self.ind: Individual = cloned.get_new_individual()
+            if use_abox:
+                cloned.solve_abox()
+            self.preprocess(cloned)
+            sol: Solution = cloned.optimize(self.obj_expr)
+            if sol.get_solution() < 0.0:
+                sol = Solution(-sol.get_solution())
+            self.set_total_time()
+            return sol
+        except InconsistentOntologyException:
+            return Solution(False)
+
+    def __str__(self) -> str:
+        if self.ind is not None:
+            return f"Is Concept {self.conc} satisfiable? [Individual {self.ind}] <= "
+        return f"Is Concept {self.conc} satisfiable? <= "

fuzzy_dl_owl2/fuzzydl/query/max/max_subsumes_query.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.implies_concept import ImpliesConcept
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.degree.degree_variable import DegreeVariable
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.individual.created_individual import CreatedIndividual
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
+from fuzzy_dl_owl2.fuzzydl.milp.term import Term
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+from fuzzy_dl_owl2.fuzzydl.query.subsumption_query import SubsumptionQuery
+from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
+from fuzzy_dl_owl2.fuzzydl.util.constants import LogicOperatorType
+
+
+class MaxSubsumesQuery(SubsumptionQuery):
+
+    def __init__(self, c1: Concept, c2: Concept, type_: LogicOperatorType) -> None:
+        super().__init__(c1, c2, type_)
+
+    def preprocess(self, kb: KnowledgeBase) -> None:
+        ind: CreatedIndividual = kb.get_new_individual()
+        if self.type == LogicOperatorType.LUKASIEWICZ:
+            conc: Concept = OperatorConcept.lukasiewicz_or(-self.c2, self.c1)
+        elif self.type == LogicOperatorType.GOEDEL:
+            conc: Concept = ImpliesConcept.goedel_implies(self.c2, self.c1)
+        elif self.type == LogicOperatorType.KLEENE_DIENES:
+            conc: Concept = ImpliesConcept.zadeh_implies(self.c2, self.c1)
+        else:  # LogicOperatorType.ZADEH
+            conc: Concept = OperatorConcept.goedel_or(-self.c2, self.c1)
+
+        q: Variable = kb.milp.get_variable(typing.cast(Individual, ind), conc)
+        kb.old_01_variables += 1
+        self.obj_expr = Expression(Term(-1.0, q))
+
+        kb.add_assertion(ind, conc, DegreeVariable.get_degree(q))
+        kb.solve_assertions()
+
+    def solve(self, kb: KnowledgeBase) -> Solution:
+        try:
+            self.set_initial_time()
+            if ConfigReader.OPTIMIZATIONS == 0 or kb.has_nominals_in_tbox():
+                cloned: KnowledgeBase = kb.clone()
+                cloned.solve_abox()
+            else:
+                cloned: KnowledgeBase = kb.clone_without_abox()
+
+            self.preprocess(cloned)
+            sol: Solution = cloned.optimize(self.obj_expr)
+            self.set_total_time()
+            return sol
+        except InconsistentOntologyException:
+            return Solution(False)
+
+    def __str__(self) -> str:
+        return f"{self.c1} subsumes {self.c2} ? <= "

fuzzy_dl_owl2/fuzzydl/query/min/__init__.py

@@ -0,0 +1,5 @@
+from .min_query import MinQuery
+from .min_instance_query import MinInstanceQuery
+from .min_related_query import MinRelatedQuery
+from .min_satisfiable_query import MinSatisfiableQuery
+from .min_subsumes_query import MinSubsumesQuery

fuzzy_dl_owl2/fuzzydl/query/min/min_instance_query.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.degree.degree_expression import DegreeExpression
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
+from fuzzy_dl_owl2.fuzzydl.milp.term import Term
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+from fuzzy_dl_owl2.fuzzydl.query.instance_query import InstanceQuery
+from fuzzy_dl_owl2.fuzzydl.util.constants import VariableType
+
+
+class MinInstanceQuery(InstanceQuery):
+    def __init__(self, concept: Concept, individual: Individual) -> None:
+        super().__init__(concept, individual)
+
+    def preprocess(self, kb: KnowledgeBase) -> None:
+        q: Variable = kb.milp.get_new_variable(VariableType.SEMI_CONTINUOUS)
+        kb.old_01_variables += 1
+        self.obj_expr: Expression = Expression(Term(1.0, q))
+
+        if "(some " in str(self.conc) or "(b-some " in str(self.conc):
+            kb.set_dynamic_blocking()
+
+        kb.add_assertion(
+            self.ind,
+            -self.conc,
+            DegreeExpression.get_degree(Expression(1.0, Term(-1.0, q))),
+        )
+        kb.solve_assertions()
+
+    def solve(self, kb: KnowledgeBase) -> Solution:
+        try:
+            self.set_initial_time()
+            kb.solve_abox()
+            cloned: KnowledgeBase = kb.clone()
+            self.preprocess(cloned)
+            sol: Solution = cloned.optimize(self.obj_expr)
+            self.set_total_time()
+            return sol
+        except InconsistentOntologyException:
+            return Solution(False)
+
+    def __str__(self) -> str:
+        return f"Is {self.ind} instance of {self.conc} ? >= "

fuzzy_dl_owl2/fuzzydl/query/min/min_query.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
+from fuzzy_dl_owl2.fuzzydl.query.query import Query
+
+
+class MinQuery(Query):
+    def __init__(self, expr: Expression) -> None:
+        self.obj_expr = expr
+
+    def preprocess(self, kb: KnowledgeBase) -> None:
+        pass
+
+    def solve(self, kb: KnowledgeBase) -> None:
+        try:
+            self.set_initial_time()
+            kb.solve_abox()
+            cloned: KnowledgeBase = kb.clone()
+            sol: Solution = cloned.optimize(self.obj_expr)
+            self.set_total_time()
+            return sol
+        except InconsistentOntologyException:
+            return Solution(False)
+
+    def __str__(self) -> str:
+        return f"{self.obj_expr} ? >= "

fuzzy_dl_owl2/fuzzydl/query/min/min_related_query.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.has_value_concept import HasValueConcept
+from fuzzy_dl_owl2.fuzzydl.degree.degree_expression import DegreeExpression
+from fuzzy_dl_owl2.fuzzydl.degree.degree_variable import DegreeVariable
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
+from fuzzy_dl_owl2.fuzzydl.milp.term import Term
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+from fuzzy_dl_owl2.fuzzydl.query.related_query import RelatedQuery
+
+
+class MinRelatedQuery(RelatedQuery):
+
+    def __init__(self, a: Individual, b: Individual, role_name: str) -> None:
+        self.ind1: Individual = a
+        self.ind2: Individual = b
+        self.role: str = role_name
+
+    def preprocess(self, kb: KnowledgeBase) -> None:
+        conc: Concept = HasValueConcept(self.role, self.ind2)
+        q: Variable = kb.milp.get_variable(self.ind1, conc)
+        kb.add_assertion(self.ind1, conc, DegreeVariable.get_degree(q))
+        kb.old_01_variables += 1
+        self.obj_expr: Expression = Expression(Term(1.0, q))
+
+        if "(some " in str(conc) or "(b-some " in str(conc):
+            kb.set_dynamic_blocking()
+
+        kb.add_assertion(
+            self.ind1,
+            -conc,
+            DegreeExpression.get_degree(Expression(1.0, Term(-1.0, q))),
+        )
+        kb.solve_assertions()
+
+    def solve(self, kb: KnowledgeBase) -> Solution:
+        try:
+            self.set_initial_time()
+            kb.old_binary_variables += 1
+            kb.solve_abox()
+            cloned: KnowledgeBase = kb.clone()
+            self.preprocess(cloned)
+            sol: Solution = cloned.optimize(self.obj_expr)
+            self.set_total_time()
+            return sol
+        except InconsistentOntologyException:
+            return Solution(False)
+
+    def __str__(self) -> str:
+        return f"Is {self.ind1} related to {self.ind2} through {self.role} ? >= "

fuzzy_dl_owl2/fuzzydl/query/min/min_satisfiable_query.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.degree.degree_expression import DegreeExpression
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
+from fuzzy_dl_owl2.fuzzydl.milp.term import Term
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+from fuzzy_dl_owl2.fuzzydl.query.satisfiable_query import SatisfiableQuery
+from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
+from fuzzy_dl_owl2.fuzzydl.util.constants import VariableType
+
+
+class MinSatisfiableQuery(SatisfiableQuery):
+
+    @typing.overload
+    def __init__(self, c: Concept) -> None: ...
+
+    @typing.overload
+    def __init__(self, c: Concept, a: Individual) -> None: ...
+
+    def __init__(self, *args) -> None:
+        assert len(args) in [1, 2]
+        assert isinstance(args[0], Concept)
+        if len(args) == 1:
+            self.__min_sat_query_init_1(*args)
+        else:
+            assert isinstance(args[1], Individual)
+            self.__min_sat_query_init_2(*args)
+
+    def __min_sat_query_init_1(self, c: Concept) -> None:
+        super().__init__(c)
+
+    def __min_sat_query_init_2(self, c: Concept, a: Individual) -> None:
+        super().__init__(c, a)
+
+    def preprocess(self, kb: KnowledgeBase) -> None:
+        if "(some " in str(self.conc) or "(b-some " in str(self.conc):
+            kb.set_dynamic_blocking()
+        q: Variable = kb.milp.get_new_variable(VariableType.SEMI_CONTINUOUS)
+        kb.old_01_variables += 1
+        self.obj_expr: Expression = Expression(Term(1.0, q))
+        kb.add_assertion(
+            self.ind,
+            -self.conc,
+            DegreeExpression.get_degree(Expression(1.0, Term(-1.0, q))),
+        )
+        kb.solve_assertions()
+
+    def solve(self, kb: KnowledgeBase) -> Solution:
+        try:
+            self.set_initial_time()
+            kb.old_binary_variables += 1
+            use_abox = self.ind is not None or ConfigReader.OPTIMIZATIONS == 0
+            cloned: KnowledgeBase = kb.clone() if use_abox else kb.clone_without_abox()
+            if self.ind is None:
+                self.ind: Individual = cloned.get_new_individual()
+            if use_abox:
+                cloned.solve_abox()
+            self.preprocess(cloned)
+            sol: Solution = cloned.optimize(self.obj_expr)
+            if sol.get_solution() < 0.0:
+                sol = Solution(-sol.get_solution())
+            self.set_total_time()
+            return sol
+
+        except InconsistentOntologyException:
+            return Solution(False)
+
+    def __str__(self) -> str:
+        if self.ind is not None:
+            return f"Is Concept {self.conc} satisfiable? [Individual {self.ind}] >= "
+        return f"Is Concept {self.conc} satisfiable? >= "