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

fuzzy_dl_owl2/fuzzydl/milp/show_variables_helper.py

@@ -11,13 +11,21 @@ from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
 
 class ShowVariablesHelper:
     def __init__(self) -> None:
+        # For every filler, the list of individuals for which the filler has to be shown
         self.abstract_fillers: dict[str, set[str]] = dict()
+        # Show the instances of these concepts
         self.concepts: set[str] = set()
+        # For every filler, the list of individuals for which the filler has to be shown
         self.concrete_fillers: dict[str, set[str]] = dict()
+        # Show these abstract fillers, for every individual
         self.global_abstract_fillers: set[str] = set()
+        # Show these concrete fillers, for every individual
         self.global_concrete_fillers: set[str] = set()
+        # Show the membership degree of these individual to every atomic concept
         self.individuals: set[str] = set()
+        # For every concrete filler, show the membership degree to these fuzzy concrete concepts
         self.labels_for_fillers: dict[str, list[FuzzyConcreteConcept]] = dict()
+        # Show these variables
         self.variables: dict[Variable, str] = dict()
 
     def clone(self) -> typing.Self:
@@ -35,15 +43,19 @@ class ShowVariablesHelper:
         return s
 
     def get_name(self, var: Variable) -> str:
+        """Gets the name of a variable."""
         return self.variables.get(var)
 
     def show_variable(self, var: Variable) -> bool:
+        """Checks whether the variable exists or not."""
         return var in self.variables
 
     def add_individual_to_show(self, ind_name: str) -> None:
+        """Shows the value of an individual to every atomic concept."""
         self.individuals.add(ind_name)
 
     def show_individuals(self, ind_name: str) -> bool:
+        """Checks whether an individual is marked to be shown or not."""
         return ind_name in self.individuals
 
     @typing.overload
@@ -58,6 +70,7 @@ class ShowVariablesHelper:
     ) -> None: ...
 
     def add_concrete_filler_to_show(self, *args) -> None:
+        """Shows the value of the fillers of a concrete feature."""
         assert len(args) in [1, 2, 3]
         assert isinstance(args[0], str)
         if len(args) == 1:
@@ -73,11 +86,24 @@ class ShowVariablesHelper:
             self.__add_concrete_filler_to_show_3(*args)
 
     def __add_concrete_filler_to_show_1(self, f_name: str) -> None:
+        """
+        Shows the value of the fillers of a concrete feature.
+
+        Args:
+            f_name (str): Name of the concrete feature.
+        """
         self.global_concrete_fillers.add(f_name)
         if f_name in self.concrete_fillers:
             del self.concrete_fillers[f_name]
 
     def __add_concrete_filler_to_show_2(self, f_name: str, ind_name: str) -> None:
+        """
+        Shows the value of the fillers of a concrete feature for an individual.
+
+        Args:
+            f_name (str): Name of the concrete feature.
+            ind_name (str): Name of the individual.
+        """
         if f_name in self.global_concrete_fillers:
             return
         self.concrete_fillers[f_name] = self.concrete_fillers.get(f_name, set()) | set(
@@ -87,9 +113,18 @@ class ShowVariablesHelper:
     def __add_concrete_filler_to_show_3(
         self, f_name: str, ind_name: str, ar: list[FuzzyConcreteConcept]
     ) -> None:
+        """
+        Shows the membership degree to some fuzzy concrete concepts (representing linguistic labels of the feature), for the fillers of a concrete feature of an individual.
+
+        Args:
+            f_name (str): Name of the concrete feature.
+            ind_name (str): Name of the individual.
+            ar (list[FuzzyConcreteConcept]): Array of fuzzy concrete concepts.
+        """
         self.add_concrete_filler_to_show(f_name, ind_name)
         name: str = f"{f_name}({ind_name})"
         aux: list[FuzzyConcreteConcept] = self.get_labels(name)
+        # Add labels to be shown
         if len(aux) > 0:
             aux.extend(ar)
             self.labels_for_fillers[name] = aux
@@ -97,6 +132,7 @@ class ShowVariablesHelper:
             self.labels_for_fillers[name] = ar
 
     def get_labels(self, var_name: str) -> list[FuzzyConcreteConcept]:
+        """Gets the fuzzy concrete concepts marked to be shown for a variable."""
         return self.labels_for_fillers.get(var_name, [])
 
     @typing.overload
@@ -106,6 +142,7 @@ class ShowVariablesHelper:
     def add_abstract_filler_to_show(self, role_name: str, ind_name: str) -> None: ...
 
     def add_abstract_filler_to_show(self, *args) -> None:
+        """Shows the membership degree to some atomic concepts of the fillers of an abstract role."""
         assert len(args) in [1, 2]
         assert isinstance(args[0], str)
         if len(args) == 1:
@@ -115,11 +152,24 @@ class ShowVariablesHelper:
             self.__add_abstract_filler_to_show_2(*args)
 
     def __add_abstract_filler_to_show_1(self, role_name: str) -> None:
+        """
+        Shows the membership degree to some atomic concepts of the fillers of an abstract role.
+
+        Args:
+            role_name (str): Name of the abstract role.
+        """
         self.global_abstract_fillers.add(role_name)
         if role_name in self.abstract_fillers:
             del self.abstract_fillers[role_name]
 
     def __add_abstract_filler_to_show_2(self, role_name: str, ind_name: str) -> None:
+        """
+        Shows the membership degree to some atomic concepts of the fillers of an abstract role for some individual.
+
+        Args:
+            role_name (str): Name of the abstract role.
+            ind_name (str): Name of the individual.
+        """
         if role_name in self.global_abstract_fillers:
             return
         self.abstract_fillers[role_name] = self.abstract_fillers.get(
@@ -127,25 +177,57 @@ class ShowVariablesHelper:
         ) | set([ind_name])
 
     def show_concrete_fillers(self, f_name: str, ind_name: str) -> bool:
+        """
+        Returns whether a given individuals is marked for showing every filler of a concrete feature.
+
+        Args:
+            f_name (str): Name of the concrete feature.
+            ind_name (str): Name of the individual.
+        """
         if f_name not in self.global_concrete_fillers:
             hs = self.concrete_fillers.get(f_name)
             return hs is not None and ind_name in hs
         return True
 
     def show_abstract_role_fillers(self, role_name: str, ind_name: str) -> bool:
+        """
+        Returns whether a given individuals is marked for showing every filler of an abstract role.
+
+        Args:
+            role_name (str): Name of the abstract role.
+            ind_name (str): Name of the individual.
+        """
         if role_name not in self.global_abstract_fillers:
             hs = self.abstract_fillers.get(role_name)
             return hs is not None and ind_name in hs
         return True
 
     def add_concept_to_show(self, conc_name: str) -> None:
+        """Show membership degree of every instance of an atomic concept."""
         self.concepts.add(conc_name)
 
     def show_concepts(self, concept_name: str) -> bool:
+        """
+        Returns whether an atomic concept is marked to show the membership degree of every individual.
+
+        Args:
+            concept_name (str): Name of atomic concept.
+
+        Returns:
+            bool: true if the concept is marked to be shown; false otherwise.
+        """
         return concept_name in self.concepts
 
     def add_variable(self, var: Variable, name_to_show: str) -> None:
+        """
+        Add a variable to shown, showing it with a given name.
+
+        Args:
+            var (Variable): A variable.
+            name_to_show (str): Name of the variable when shown.
+        """
         self.variables[var] = name_to_show
 
     def get_variables(self) -> list[Variable]:
+        """Gets the variables to be shown."""
         return list(self.variables.keys())

fuzzy_dl_owl2/fuzzydl/milp/solution.py

@@ -4,7 +4,9 @@ from fuzzy_dl_owl2.fuzzydl.util import constants
 
 
 class Solution:
+    # Indicates whether the fuzzy KB is consistent
     CONSISTENT_KB: bool = True
+    # Indicates whether the fuzzy KB is inconsistent
     INCONSISTENT_KB: bool = False
 
     @typing.overload
@@ -23,19 +25,40 @@ class Solution:
             raise ValueError
 
     def __solution_init_1(self, consistent: bool) -> None:
+        # Numerical value of the solution
         self.sol: typing.Union[bool, float] = 0.0
+        # Consistency of the fuzzy KB
         self.consistent: bool = consistent
+        # Value of the showed variables
+        self.showed_variables: dict[str, float] = dict()
 
     def __solution_init_2(self, sol: float) -> None:
+        # Numerical value of the solution
         self.sol: typing.Union[bool, float] = sol
+        # Consistency of the fuzzy KB
         self.consistent: bool = True
+        # Value of the showed variables
+        self.showed_variables: dict[str, float] = dict()
 
     def is_consistent_kb(self) -> bool:
+        """Indicates whether the original KB is consistent or not."""
         return self.consistent
 
     def get_solution(self) -> typing.Union[bool, float]:
+        """Gets the solution to some query over a consistent KB."""
         return self.sol
 
+    def get_showed_variables(self) -> dict[str, float]:
+        """Gets the values of some variables after solving a query over a consistent KB."""
+        return self.showed_variables
+
+    def add_showed_variable(self, var_name: str, value: float) -> None:
+        """Sets the value of a showed variable."""
+        self.showed_variables[var_name] = value
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
     def __repr__(self) -> str:
         return str(self)
 

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/milp/variable.py

@@ -4,14 +4,21 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import VariableType
 
 
 class Variable:
+    # Name of new variables
     VARIABLE_NAME: str = "y"
+    # Number of new variables
     VARIABLE_NUMBER: int = 0
 
     def __init__(self, name: str, v_type: VariableType) -> None:
+        # Lower bound of the variable
         self.lower_bound: float = 0.0
+        # Upper bound of the variable
         self.upper_bound: float = 0.0
+        # Name of the variable
         self.name: str = name
+        # Type of the variable
         self.type: VariableType = None
+        # Variable is filler value of datatype restriction
         self.datatype_filler: bool = False
         self.set_type(v_type)
 

fuzzy_dl_owl2/fuzzydl/modifier/linear_modifier.py

@@ -11,6 +11,9 @@ from fuzzy_dl_owl2.fuzzydl.modifier.modifier import Modifier
 
 
 class LinearModifier(Modifier):
+    """
+    Linear modifier with parameter c
+    """
 
     def __init__(self, name: str, c: float) -> None:
         super().__init__(name)

fuzzy_dl_owl2/fuzzydl/modifier/modifier.py

@@ -7,6 +7,9 @@ from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
 
 
 class Modifier(ABC):
+    """
+    Fuzzy modifier.
+    """
 
     def __init__(self, name: str) -> None:
         self.name: str = name
@@ -24,10 +27,28 @@ class Modifier(ABC):
 
     @abstractmethod
     def modify(self, concept: Concept) -> Concept:
+        """
+        Modifies a fuzzy concept.
+
+        Args:
+            concept (Concept): A fuzzy concept
+
+        Returns:
+            Concept: Fuzzy concept resulting from the application of the modifier to c.
+        """
         pass
 
     @abstractmethod
     def get_membership_degree(self, value: float) -> float:
+        """
+        Gets the image in [0,1] of a real number to the modifier.
+
+        Args:
+            value (float): A real number in the range of values of the modifier function.
+
+        Returns:
+            float: Image in [0,1] of x to the explicit modifier function.
+        """
         pass
 
     def __repr__(self) -> str:

fuzzy_dl_owl2/fuzzydl/parser/dl_parser.py

@@ -48,6 +48,7 @@ from fuzzy_dl_owl2.fuzzydl.concept.owa_concept import OwaConcept
 from fuzzy_dl_owl2.fuzzydl.concept.qowa_concept import QowaConcept
 from fuzzy_dl_owl2.fuzzydl.concept.quasi_sugeno_integral import QsugenoIntegral
 from fuzzy_dl_owl2.fuzzydl.concept.self_concept import SelfConcept
+from fuzzy_dl_owl2.fuzzydl.concept.sigma_concept import SigmaConcept
 from fuzzy_dl_owl2.fuzzydl.concept.sugeno_integral import SugenoIntegral
 from fuzzy_dl_owl2.fuzzydl.concept.threshold_concept import ThresholdConcept
 from fuzzy_dl_owl2.fuzzydl.concept.truth_concept import TruthConcept
@@ -564,6 +565,32 @@ class DLParser(object):
             return pp.ParseResults([QsugenoIntegral(weights, concepts)])
         return tokens
 
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_sigma_count_concept(tokens: pp.ParseResults) -> pp.ParseResults:
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_sigma_count_concept -> {tokens}")
+        list_tokens: list[str] = tokens.as_list()
+        role: str = list_tokens[0]
+        concept: Concept = DLParser._to_concept(list_tokens[1])
+        individuals: list[Individual] = [
+            DLParser.kb.get_individual(token) for token in list_tokens[2:-1]
+        ]
+        concept_name: str = list_tokens[-1]
+        if concept_name not in DLParser.kb.concrete_concepts:
+            Util.error(f"Error: Fuzzy cocnept {concept_name} has not been defined")
+        fuzzy_concept: Concept = DLParser.kb.get_concept(concept_name)
+        if not isinstance(
+            fuzzy_concept,
+            (RightConcreteConcept, LeftConcreteConcept, TriangularConcreteConcept),
+        ):
+            Util.error(
+                f"Error: Fuzzy concept {fuzzy_concept} has to be a left, right or a triangular function."
+            )
+        return pp.ParseResults(
+            [SigmaConcept(concept, role, individuals, fuzzy_concept)]
+        )
+
     @staticmethod
     # @pp.trace_parse_action
     def _parse_modifier(tokens: pp.ParseResults) -> pp.ParseResults:
@@ -973,7 +1000,6 @@ class DLParser(object):
     @staticmethod
     # @pp.trace_parse_action
     def _parse_constraints(tokens: pp.ParseResults) -> pp.ParseResults:
-
         if ConfigReader.DEBUG_PRINT:
             Util.debug(f"\t\t_parse_constraints -> {tokens}")
         list_tokens: list = tokens.as_list()
@@ -1456,6 +1482,8 @@ class DLParser(object):
 
         lbrace = pp.Literal("(").set_results_name("lbrace").suppress()
         rbrace = pp.Literal(")").set_results_name("rbrace").suppress()
+        lbbrace = pp.Literal("{").set_results_name("lbbrace").suppress()
+        rbbrace = pp.Literal("}").set_results_name("rbbrace").suppress()
         comment = pp.one_of(["#", "%"]).set_results_name("comment").suppress()
         any_not_newline = (
             pp.Regex("[^\n]+").set_results_name("any_not_newline").suppress()
@@ -1737,6 +1765,17 @@ class DLParser(object):
                 )
                 .set_results_name("owa_integrals", list_all_matches=True)
                 .set_parse_action(DLParser._parse_owa_integral_concept)
+                | (
+                    FuzzyDLKeyword.SIGMA_COUNT.get_value().suppress()
+                    + variables  # role
+                    + concept
+                    + lbbrace
+                    + variables[1, ...]  # list of individuals
+                    + rbbrace
+                    + variables  # fuzzy concept name
+                )
+                .set_results_name("sigma_count", list_all_matches=True)
+                .set_parse_action(DLParser._parse_sigma_count_concept)
             )
             + rbrace
         )
@@ -1897,13 +1936,15 @@ class DLParser(object):
             (
                 lbrace
                 + FuzzyDLKeyword.CONSTRAINTS.get_value()
-                + lbrace
                 + (
-                    inequation
-                    | FuzzyDLKeyword.BINARY.get_value() + variables
-                    | FuzzyDLKeyword.FREE.get_value() + variables
-                )
-                + rbrace
+                    lbrace
+                    + (
+                        inequation
+                        | FuzzyDLKeyword.BINARY.get_value() + variables
+                        | FuzzyDLKeyword.FREE.get_value() + variables
+                    )
+                    + rbrace
+                )[1, ...]
                 + rbrace
             )
             .set_results_name("constraints", list_all_matches=True)

fuzzy_dl_owl2/fuzzydl/primitive_concept_definition.py

@@ -7,6 +7,9 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import LogicOperatorType
 
 
 class PrimitiveConceptDefinition:
+    """
+    General concept inclusion axiom.
+    """
 
     def __init__(
         self,
@@ -15,9 +18,13 @@ class PrimitiveConceptDefinition:
         implication: LogicOperatorType,
         degree: float,
     ) -> None:
+        # Subsumer concept
         self.defined: str = defined
+        # Subsumed concept
         self.definition: Concept = definition
+        # Lower bound degree
         self.degree: float = degree
+        # Axiom type (depends on the fuzzy implication)
         self.implication: LogicOperatorType = implication
 
     def clone(self) -> typing.Self:

fuzzy_dl_owl2/fuzzydl/query/__init__.py

@@ -6,6 +6,7 @@ from .related_query import RelatedQuery
 from .satisfiable_query import SatisfiableQuery
 from .subsumption_query import SubsumptionQuery
 from .all_instances_query import AllInstancesQuery
+from .classification_query import ClassificationQuery
 
 from .max import *
 

fuzzy_dl_owl2/fuzzydl/query/all_instances_query.py

@@ -1,17 +1,31 @@
 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.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.milp_helper import MILPHelper
 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.min.min_instance_query import MinInstanceQuery
 from fuzzy_dl_owl2.fuzzydl.query.query import Query
+from fuzzy_dl_owl2.fuzzydl.util.constants import VariableType
 from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 
 class AllInstancesQuery(Query):
+    """
+    Min instance query for every individual of a knowledge base.
+    """
+
     def __init__(self, concept: Concept) -> None:
+        super().__init__()
         if concept.is_concrete():
             Util.error(f"Error: {concept} cannot be a concrete concept.")
         self.conc = concept
@@ -27,6 +41,11 @@ class AllInstancesQuery(Query):
         self.name: str = ""
         self.individuals: list[Individual] = list(kb.individuals.values())
 
+        try:
+            kb.solve_abox()
+        except InconsistentOntologyException as e:
+            return Solution(Solution.INCONSISTENT_KB)
+
         for i in self.individuals:
             if isinstance(i, CreatedIndividual):
                 continue
@@ -34,12 +53,72 @@ class AllInstancesQuery(Query):
             sol: Solution = q.solve(kb)
             if sol.is_consistent_kb():
                 self.degrees.append(float(sol.get_solution()))
-                self.name += f"{q}{sol.get_solution()}"
+                self.name += f"{q}{sol.get_solution()}\n"
                 continue
             self.name = f"Instances of {self.conc}? Inconsistent KB"
             break
         return sol
 
+    def solve_new(self, kb: KnowledgeBase) -> Solution:
+        """
+        Specific algorithm to solve the instance retrieval.
+        """
+        self.name: str = ""
+        new_variables: list[Variable] = list()
+        var_names: dict[str, str] = dict()
+        self.individuals: list[Individual] = list(kb.individuals.values())
+        cloned: KnowledgeBase = kb.clone()
+
+        try:
+            cloned.solve_abox()
+        except InconsistentOntologyException as e:
+            return Solution(Solution.INCONSISTENT_KB)
+
+        for i in self.individuals:
+            if isinstance(i, CreatedIndividual):
+                continue
+            q: Variable = cloned.milp.get_new_variable(VariableType.SEMI_CONTINUOUS)
+            cloned.old_01_variables += 1
+            s: str = f"Is {i} instance of {self.conc}? >= "
+            var_names[str(q)] = s
+            cloned.milp.show_vars.add_variable(q, s)
+            new_variables.append(q)
+            # a: not c >= 1-q
+            cloned.add_assertion(
+                i,
+                -self.conc,
+                DegreeExpression.get_degree(Expression(1.0, Term(-1.0, q))),
+            )
+        cloned.solve_assertions()
+        obj_expr: Expression = Expression()
+        for var in new_variables:
+            obj_expr.add_term(Term(1.0, var))
+    
+        MILPHelper.PRINT_LABELS = False
+        MILPHelper.PRINT_VARIABLES = False
+        MILPHelper.PARTITION = True
+        sol: Solution = cloned.optimize(obj_expr)
+        MILPHelper.PARTITION = False
+        MILPHelper.PRINT_LABELS = True
+        MILPHelper.PRINT_VARIABLES = True
+
+        if sol.is_consistent_kb():
+            ht: dict[str, float] = sol.get_showed_variables()
+            individuals_and_degrees: dict[str, float] = dict()
+            for s in ht:
+                var_name: str = var_names.get(s)
+                value: float = ht.get(s)
+                self.name += f"{var_name} {value}\n"
+                individuals_and_degrees[var_name, value]
+
+            for i in range(len(self.individuals)):
+                var_name: str = f"Is {self.individuals[i]} instance of {self.conc} >= "
+                value: float = individuals_and_degrees.get(var_name)
+                self.degrees.append(value)
+        else:
+            self.name = f"Instances of {self.conc}? Inconsistent KB"
+        return sol
+
     def get_individuals(self) -> list[Individual]:
         return self.individuals
 

fuzzy_dl_owl2/fuzzydl/query/bnp_query.py

@@ -9,7 +9,9 @@ from fuzzy_dl_owl2.fuzzydl.query.query import Query
 
 
 class BnpQuery(Query):
+
     def __init__(self, c: TriangularFuzzyNumber) -> None:
+        super().__init__()
         self.c: TriangularFuzzyNumber = c
 
     def preprocess(self, kb: KnowledgeBase) -> None:

fuzzy_dl_owl2/fuzzydl/query/classification_query.py

@@ -0,0 +1,26 @@
+import traceback
+
+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
+from fuzzy_dl_owl2.fuzzydl.util.util import Util
+
+
+class ClassificationQuery(Query):
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def preprocess(self, kb: KnowledgeBase) -> None:
+        pass
+
+    def solve(self, kb: KnowledgeBase) -> Solution:
+        try:
+            kb.classify()
+            return Solution(1.0)
+        except Exception as ex:
+            Util.debug(traceback.format_exc())
+            return Solution(Solution.INCONSISTENT_KB)
+
+    def __str__(self) -> str:
+        return "Classify? <= "

fuzzy_dl_owl2/fuzzydl/query/defuzzify/defuzzify_query.py

@@ -24,6 +24,7 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 class DefuzzifyQuery(Query):
 
     def __init__(self, c: Concept, ind: Individual, feature_name: str) -> None:
+        super().__init__()
         self.conc: Concept = c
         self.a: Individual = ind
         self.f_name: str = feature_name
@@ -69,7 +70,7 @@ class DefuzzifyQuery(Query):
             Util.warning("Warning: Problem in defuzzification. Answer is 0.")
             return None
         except InconsistentOntologyException:
-            return Solution(False)
+            return Solution(Solution.INCONSISTENT_KB)
 
     @abstractmethod
     def get_obj_expression(self, variable: Variable) -> Expression:

fuzzy_dl_owl2/fuzzydl/query/defuzzify/lom_defuzzify_query.py

@@ -9,6 +9,10 @@ from fuzzy_dl_owl2.fuzzydl.query.defuzzify.defuzzify_query import DefuzzifyQuery
 
 
 class LomDefuzzifyQuery(DefuzzifyQuery):
+    """
+    Largest of maxima defuzzification query
+    """
+
     def __init__(self, c: Concept, ind: Individual, feature_name: str) -> None:
         super().__init__(c, ind, feature_name)
 

fuzzy_dl_owl2/fuzzydl/query/defuzzify/mom_defuzzify_query.py

@@ -25,6 +25,9 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 
 class MomDefuzzifyQuery(DefuzzifyQuery):
+    """
+    Middle of maxima defuzzification query.
+    """
 
     def __init__(self, c: Concept, ind: Individual, feature_name: str) -> None:
         super().__init__(c, ind, feature_name)
@@ -51,7 +54,7 @@ class MomDefuzzifyQuery(DefuzzifyQuery):
                 Util.warning("Warning: Problem in defuzzification. Answer is 0.")
                 return None
         except InconsistentOntologyException:
-            return Solution(False)
+            return Solution(Solution.INCONSISTENT_KB)
 
         rel_set: list[Relation] = ind.role_relations.get(self.f_name)
         b: CreatedIndividual = typing.cast(
@@ -86,9 +89,10 @@ class MomDefuzzifyQuery(DefuzzifyQuery):
             traceback.print_exc()
         except InconsistentOntologyException as e:
             traceback.print_exc()
-        return Solution(False)
+        return Solution(Solution.INCONSISTENT_KB)
 
     def get_obj_expression(self, variable: Variable) -> Expression:
+        # Put anything here, we do not use this method
         return Expression(Term(-1.0, variable))
 
     def __str__(self) -> str: