PyPI - fuzzy-dl-owl2 - Versions diffs - 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl - Mend

fuzzy-dl-owl2 1.0.2py3-none-any.whl → 1.0.3py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

fuzzy_dl_owl2/fuzzydl/knowledge_base.py CHANGED Viewed

@@ -10,79 +10,84 @@ from sortedcontainers import SortedSet
 from fuzzy_dl_owl2.fuzzydl.assertion.assertion import Assertion
 from fuzzy_dl_owl2.fuzzydl.concept.all_some_concept import AllSomeConcept
-from fuzzy_dl_owl2.fuzzydl.concept.approximation_concept import \
-    ApproximationConcept
+from fuzzy_dl_owl2.fuzzydl.concept.approximation_concept import ApproximationConcept
 from fuzzy_dl_owl2.fuzzydl.concept.atomic_concept import AtomicConcept
 from fuzzy_dl_owl2.fuzzydl.concept.choquet_integral import ChoquetIntegral
 from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.crisp_concrete_concept import \
-    CrispConcreteConcept
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_concrete_concept import \
-    FuzzyConcreteConcept
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_number.triangular_fuzzy_number import \
-    TriangularFuzzyNumber
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.left_concrete_concept import \
-    LeftConcreteConcept
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.linear_concrete_concept import \
-    LinearConcreteConcept
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.modified_concrete_concept import \
-    ModifiedConcreteConcept
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.right_concrete_concept import \
-    RightConcreteConcept
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.trapezoidal_concrete_concept import \
-    TrapezoidalConcreteConcept
-from fuzzy_dl_owl2.fuzzydl.concept.concrete.triangular_concrete_concept import \
-    TriangularConcreteConcept
-from fuzzy_dl_owl2.fuzzydl.concept.ext_threshold_concept import \
-    ExtThresholdConcept
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.crisp_concrete_concept import (
+    CrispConcreteConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_concrete_concept import (
+    FuzzyConcreteConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_number.triangular_fuzzy_number import (
+    TriangularFuzzyNumber,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.left_concrete_concept import (
+    LeftConcreteConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.linear_concrete_concept import (
+    LinearConcreteConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.modified_concrete_concept import (
+    ModifiedConcreteConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.right_concrete_concept import (
+    RightConcreteConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.trapezoidal_concrete_concept import (
+    TrapezoidalConcreteConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.triangular_concrete_concept import (
+    TriangularConcreteConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.ext_threshold_concept import ExtThresholdConcept
 from fuzzy_dl_owl2.fuzzydl.concept.has_value_concept import HasValueConcept
 from fuzzy_dl_owl2.fuzzydl.concept.implies_concept import ImpliesConcept
-from fuzzy_dl_owl2.fuzzydl.concept.interface.has_concepts_interface import \
-    HasConceptsInterface
-from fuzzy_dl_owl2.fuzzydl.concept.interface.has_role_interface import \
-    HasRoleInterface
-from fuzzy_dl_owl2.fuzzydl.concept.interface.has_value_interface import \
-    HasValueInterface
-from fuzzy_dl_owl2.fuzzydl.concept.modified.modified_concept import \
-    ModifiedConcept
-from fuzzy_dl_owl2.fuzzydl.concept.modified.triangularly_modified_concept import \
-    TriangularlyModifiedConcept
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_concepts_interface import (
+    HasConceptsInterface,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_role_interface import HasRoleInterface
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_value_interface import (
+    HasValueInterface,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.modified.modified_concept import ModifiedConcept
+from fuzzy_dl_owl2.fuzzydl.concept.modified.triangularly_modified_concept import (
+    TriangularlyModifiedConcept,
+)
 from fuzzy_dl_owl2.fuzzydl.concept.negated_nominal import NegatedNominal
 from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
 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.quasi_sugeno_integral import QsugenoIntegral
 from fuzzy_dl_owl2.fuzzydl.concept.self_concept import SelfConcept
 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
 from fuzzy_dl_owl2.fuzzydl.concept.value_concept import ValueConcept
 from fuzzy_dl_owl2.fuzzydl.concept.weighted_concept import WeightedConcept
-from fuzzy_dl_owl2.fuzzydl.concept.weighted_max_concept import \
-    WeightedMaxConcept
-from fuzzy_dl_owl2.fuzzydl.concept.weighted_min_concept import \
-    WeightedMinConcept
-from fuzzy_dl_owl2.fuzzydl.concept.weighted_sum_concept import \
-    WeightedSumConcept
-from fuzzy_dl_owl2.fuzzydl.concept.weighted_sum_zero_concept import \
-    WeightedSumZeroConcept
+from fuzzy_dl_owl2.fuzzydl.concept.weighted_max_concept import WeightedMaxConcept
+from fuzzy_dl_owl2.fuzzydl.concept.weighted_min_concept import WeightedMinConcept
+from fuzzy_dl_owl2.fuzzydl.concept.weighted_sum_concept import WeightedSumConcept
+from fuzzy_dl_owl2.fuzzydl.concept.weighted_sum_zero_concept import (
+    WeightedSumZeroConcept,
+)
 from fuzzy_dl_owl2.fuzzydl.concept_equivalence import ConceptEquivalence
 from fuzzy_dl_owl2.fuzzydl.concrete_feature import ConcreteFeature
 from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
 from fuzzy_dl_owl2.fuzzydl.degree.degree_expression import DegreeExpression
 from fuzzy_dl_owl2.fuzzydl.degree.degree_numeric import DegreeNumeric
 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.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
 from fuzzy_dl_owl2.fuzzydl.feature_function import FeatureFunction
-from fuzzy_dl_owl2.fuzzydl.general_concept_inclusion import \
-    GeneralConceptInclusion
-from fuzzy_dl_owl2.fuzzydl.individual.created_individual import \
-    CreatedIndividual
+from fuzzy_dl_owl2.fuzzydl.general_concept_inclusion import GeneralConceptInclusion
+from fuzzy_dl_owl2.fuzzydl.individual.created_individual import CreatedIndividual
 from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
-from fuzzy_dl_owl2.fuzzydl.individual.representative_individual import \
-    RepresentativeIndividual
+from fuzzy_dl_owl2.fuzzydl.individual.representative_individual import (
+    RepresentativeIndividual,
+)
 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
@@ -90,28 +95,38 @@ from fuzzy_dl_owl2.fuzzydl.milp.term import Term
 from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
 from fuzzy_dl_owl2.fuzzydl.modifier.linear_modifier import LinearModifier
 from fuzzy_dl_owl2.fuzzydl.modifier.modifier import Modifier
-from fuzzy_dl_owl2.fuzzydl.modifier.triangular_modifier import \
-    TriangularModifier
-from fuzzy_dl_owl2.fuzzydl.primitive_concept_definition import \
-    PrimitiveConceptDefinition
+from fuzzy_dl_owl2.fuzzydl.modifier.triangular_modifier import TriangularModifier
+from fuzzy_dl_owl2.fuzzydl.primitive_concept_definition import (
+    PrimitiveConceptDefinition,
+)
 from fuzzy_dl_owl2.fuzzydl.relation import Relation
-from fuzzy_dl_owl2.fuzzydl.restriction.has_value_restriction import \
-    HasValueRestriction
+from fuzzy_dl_owl2.fuzzydl.restriction.has_value_restriction import HasValueRestriction
 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.constants import (
-    BlockingDynamicType, ConceptType, ConcreteFeatureType,
-    CreatedIndividualBlockingType, FeatureFunctionType, FuzzyLogic,
-    InequalityType, KnowledgeBaseRules, LogicOperatorType,
-    RepresentativeIndividualType, RestrictionType, VariableType)
+    BlockingDynamicType,
+    ConceptType,
+    ConcreteFeatureType,
+    CreatedIndividualBlockingType,
+    FeatureFunctionType,
+    FuzzyLogic,
+    InequalityType,
+    KnowledgeBaseRules,
+    LogicOperatorType,
+    RepresentativeIndividualType,
+    RestrictionType,
+    VariableType,
+)
 from fuzzy_dl_owl2.fuzzydl.util.util import Util
+from fuzzy_dl_owl2.fuzzydl.util.utils import class_debugging
+@class_debugging()
 class KnowledgeBase:
-    VERSION: float = 2.0
     def __init__(self) -> None:
+        Variable.VARIABLE_NUMBER = 0
         self.language: str = ""
         self.milp: MILPHelper = MILPHelper()
@@ -342,7 +357,9 @@ class KnowledgeBase:
             k: [r.clone() for r in v] for k, v in self.temp_relations_list.items()
         }
         kb.t_G = [gci.clone() for gci in self.t_G]
-        kb.t_inclusions = {k: set([pcd.clone() for pcd in v]) for k, v in self.t_inclusions.items()}
+        kb.t_inclusions = {
+            k: set([pcd.clone() for pcd in v]) for k, v in self.t_inclusions.items()
+        }
         kb.transitive_roles = copy.deepcopy(self.transitive_roles)
         kb.t_synonyms = copy.deepcopy(self.t_synonyms)
         return kb
@@ -746,9 +763,9 @@ class KnowledgeBase:
         return rel
     def define_synonym(self, concept_name_1: str, concept_name_2: str) -> None:
-        self.t_synonyms[concept_name_1] = self.t_synonyms.get(concept_name_1, set()) | set(
-            [concept_name_2]
-        )
+        self.t_synonyms[concept_name_1] = self.t_synonyms.get(
+            concept_name_1, set()
+        ) | set([concept_name_2])
         self.get_concept(concept_name_1)
     def define_synonyms(self, concept_name_1: str, concept_name_2: str) -> None:
@@ -1262,7 +1279,9 @@ class KnowledgeBase:
     def add_simple_inverse_roles(self, role: str, inv_role: str) -> None:
         self.inverse_roles[role] = self.inverse_roles.get(role, set()) | set([inv_role])
-        self.inverse_roles[inv_role] = self.inverse_roles.get(inv_role, set()) | set([role])
+        self.inverse_roles[inv_role] = self.inverse_roles.get(inv_role, set()) | set(
+            [role]
+        )
         if role in self.inverse_functional_roles:
             self.functional_roles.add(inv_role)
         if inv_role in self.inverse_functional_roles:
@@ -1746,7 +1765,7 @@ class KnowledgeBase:
         Util.debug(f"{constants.SEPARATOR}GCI completed{constants.SEPARATOR}")
     def solve_reflexive_role(self, role: str) -> None:
-        for ind in self.individuals:
+        for ind in self.individuals.values():
             self.add_relation(ind, role, ind, DegreeNumeric.get_degree(1.0))
     @typing.overload
@@ -1789,7 +1808,7 @@ class KnowledgeBase:
     def __get_correct_version_of_individual_1(self, ass: Assertion) -> None:
         ind: Individual = ass.get_individual()
         ind2: Individual = self.individuals.get(str(ind))
-        if ind == ind2:
+        if id(ind) == id(ind2):
             return
         if ind2 is None:
             ind2 = self.get_individual(str(ind))
@@ -1799,7 +1818,7 @@ class KnowledgeBase:
     def __get_correct_version_of_individual_2(self, rel: Relation) -> None:
         ind: Individual = rel.get_object_individual()
         ind2: Individual = self.individuals.get(str(ind))
-        if ind == ind2:
+        if id(ind) == id(ind2):
             return
         if ind2 is None:
             ind2 = self.get_individual(str(ind))
@@ -1880,28 +1899,44 @@ class KnowledgeBase:
                 self.individuals[b_name] = a
     def merge(self, a: Individual, b: Individual) -> None:
+        """
+        Merges two individuals.
+        """
         if isinstance(a, CreatedIndividual) and not isinstance(b, CreatedIndividual):
+            # Swap b and a, so the created individual is merged into the root individual
             a, b = b, a
         a_name, b_name = str(a), str(b)
         Util.debug(f"Merging individual {b_name} into {a_name}")
+        # To do: nominal variables needed only if language contains "B"
+        # Unique Name Assumption
         if not isinstance(a, CreatedIndividual) and not isinstance(
             b, CreatedIndividual
         ):
+            # xAisA + xBisB <= 1
             x_a_is_a: Variable = self.milp.get_nominal_variable(a_name)
             x_b_is_b: Variable = self.milp.get_nominal_variable(b_name, b_name)
             self.milp.add_new_constraint(
                 Expression(-1.0, Term(1.0, x_a_is_a), Term(1.0, x_b_is_b)),
                 InequalityType.LESS_THAN,
             )
+            # Add { b } to a
             self.add_labels_with_nodes(b_name, a_name)
+        # --------------------------------------------------------------
+        # 1. Move edges leading to b so that they lead to a
+        # --------------------------------------------------------------
         for i in self.individuals.values():
             for array in i.role_relations.values():
                 for r in array:
                     if r.get_object_individual() == b:
                         r.set_object_individual(a)
+        # --------------------------------------------------------------------------
+        # 2. Move edges leading from b to a nominal node so that they lead from a
+        # --------------------------------------------------------------------------
         to_remove: set[str] = set()
         for role, b_rels in b.role_relations.items():
             new_rels: list[Relation] = []
@@ -1910,18 +1945,21 @@ class KnowledgeBase:
                 if not r.get_object_individual().is_blockable():
                     r.set_subject_individual(a)
                     a_rels.append(r)
-                    continue
-                new_rels.append(r)
+                else:
+                    new_rels.append(r)
             a.role_relations[role] = a_rels
             if len(new_rels) == 0:
                 to_remove.add(role)
-                continue
-            b.role_relations[role] = new_rels
+            else:
+                b.role_relations[role] = new_rels
         for role in to_remove:
             del b.role_relations[role]
+        # -------------------------------------------------------
+        # 3. Concept assertions using b, now use a
+        # -----------------------------------------------------
         for ass in self.assertions:
             if str(ass.get_individual()) == b_name:
                 ass.set_individual(a)
@@ -1930,8 +1968,15 @@ class KnowledgeBase:
             if str(ass.get_individual()) == b_name:
                 ass.set_individual(a)
+        # -----------------------------------------
+        # 4. Variables using b, now use a
+        # -----------------------------------------
         param: bool = isinstance(b, CreatedIndividual)
         self.milp.change_variable_names(b_name, a_name, param)
+        # -----------------------------------------
+        # 5. Prune
+        # -----------------------------------------
         b.prune()
     def goedel_implies(self, conc1: Concept, conc2: Concept, degree: Degree) -> None:
@@ -2222,9 +2267,11 @@ class KnowledgeBase:
                 role = typing.cast(AllSomeConcept, conc2).role
                 c_range: Concept = typing.cast(AllSomeConcept, conc2).curr_concept
             else:
-                assert isinstance(conc2, HasValueInterface)
-                role = conc2.role
-                c_range: Concept = NegatedNominal(str(conc2.value))
+                assert isinstance(conc2, OperatorConcept)
+                has_value: Concept = conc2.get_atom()
+                assert isinstance(has_value, HasValueInterface)
+                role = has_value.role
+                c_range: Concept = NegatedNominal(str(has_value.value))
             self.role_range(role, c_range)
             self.remove_C_is_a_X(key, tau, atomic)
             Util.debug(f"Absorbed: range {role}, {c_range}")
@@ -2240,8 +2287,14 @@ class KnowledgeBase:
             if (
                 type_c2 == ConceptType.ALL or OperatorConcept.is_not_has_value(conc2)
             ) and degree_is_one:
-                assert isinstance(conc2, HasRoleInterface)
-                role: str = conc2.role
+                if OperatorConcept.is_not_has_value(conc2):
+                    atom: Concept = typing.cast(OperatorConcept, conc2).get_atom()
+                    assert isinstance(atom, HasRoleInterface)
+                    role: str = atom.role
+                else:
+                    assert isinstance(conc2, HasRoleInterface)
+                    role: str = conc2.role
                 if self.is_crisp_role(role) and (
                     implication_type != LogicOperatorType.KLEENE_DIENES
                     or constants.KNOWLEDGE_BASE_SEMANTICS == FuzzyLogic.CLASSICAL
@@ -2266,11 +2319,15 @@ class KnowledgeBase:
                             -conc1,
                         )
                     else:
-                        assert isinstance(conc2, HasValueInterface)
                         g_imp_concept: Concept = ImpliesConcept.goedel_implies(
                             HasValueConcept(
                                 role,
-                                str(conc2.value),
+                                str(
+                                    typing.cast(
+                                        HasValueConcept,
+                                        typing.cast(OperatorConcept, conc2).get_atom(),
+                                    ).value
+                                ),
                             ),
                             -conc1,
                         )
@@ -2848,7 +2905,7 @@ class KnowledgeBase:
             Util.debug("No optimization: DOUBLE_BLOCKING + dynamicblocking")
             return
         if len(self.inverse_roles) == 0 or len(self.functional_roles) == 0:
-            if len(self.t_G) == 0 or self.is_tbox_acyclic():
+            if len(self.t_G) == 0 and self.is_tbox_acyclic():
                 self.blocking_type = BlockingDynamicType.NO_BLOCKING
                 Util.debug("NO_BLOCKING")
             else:
@@ -2945,6 +3002,10 @@ class KnowledgeBase:
     def __restrict_range_2(
         self, x_b: Variable, x_f: Variable, k1: float, k2: float
     ) -> None:
+        """
+        Restricts the range of a variable to [k1, k2] if x_f not zero
+        """
+        # x_b \geq k1
         self.milp.add_new_constraint(
             Expression(
                 constants.MAXVAL,
@@ -2954,6 +3015,7 @@ class KnowledgeBase:
             ),
             InequalityType.GREATER_THAN,
         )
+        # x_b \leq k2
         self.milp.add_new_constraint(
             Expression(
                 -constants.MAXVAL,
@@ -3048,8 +3110,6 @@ class KnowledgeBase:
     def solve_kb(self) -> None:
         if constants.KNOWLEDGE_BASE_SEMANTICS is None:
             self.set_logic(FuzzyLogic.LUKASIEWICZ)
-        if ConfigReader.SHOW_VERSION:
-            Util.info(f"Version: {self.get_version()}")
         self.compute_language()
         self.convert_strings_into_integers()
         self.solve_inverse_roles()
@@ -3136,188 +3196,203 @@ class KnowledgeBase:
                     Util.debug(
                         f"{constants.SEPARATOR}Assertion completed{constants.SEPARATOR}"
                     )
+                    continue
+                # Use right version of the individual (needed when we clone the KB or merge individuals)
+                self.get_correct_version_of_individual(ass)
+                if ass.get_individual().is_blockable():
+                    Util.debug(
+                        f"Direct Blocking status {typing.cast(CreatedIndividual, ass.get_individual()).directly_blocked}"
+                    )
+                    Util.debug(
+                        f"Indirect Blocking status {typing.cast(CreatedIndividual, ass.get_individual()).indirectly_blocked}"
+                    )
+                # If the individual is indirectly blocked we skip the assertion
+                if (
+                    ass.get_individual().is_blockable()
+                    and CreatedIndividualHandler.is_indirectly_blocked(
+                        typing.cast(CreatedIndividual, ass.get_individual()), self
+                    )
+                ):
+                    name: str = str(ass.get_individual())
+                    Util.debug(
+                        "Skipping assertion (it has an indirectly blocked individual)"
+                    )
+                    self.blocked_assertions[name] = self.blocked_assertions.get(
+                        name, []
+                    ) + [ass]
+                    continue
+                # Add xAss >= lowerBound
+                self.milp.add_new_constraint(ass)
+                if self.is_assertion_processed(ass):
+                    Util.debug(
+                        f"Assertion (without the degree): {ass} already processed."
+                    )
+                    continue
+                ind: Individual = ass.get_individual()
+                ci: Concept = ass.get_concept()
+                self.add_negated_equations(ind, ci)
+                c_type: ConceptType = ass.get_type()
+                # Apply reasoning rule according to the type of the assertion
+                if c_type == ConceptType.ATOMIC:
+                    self.rule_atomic(ass)
+                elif ci.is_complemented_atomic():
+                    self.rule_complemented_atomic(ass)
+                elif c_type == ConceptType.AND:
+                    self.rule_and(ass)
+                elif c_type == ConceptType.OR:
+                    self.rule_or(ass)
+                elif c_type in (ConceptType.SOME, ConceptType.HAS_VALUE):
+                    self.exist_assertions.append(ass)
+                    continue
+                elif c_type == ConceptType.ALL:
+                    self.rule_all(ass)
+                elif OperatorConcept.is_not_has_value(ci):
+                    self.rule_complemented_has_value(ass)
+                elif c_type == ConceptType.CONCRETE:
+                    self.rule_concrete(ass)
+                elif OperatorConcept.is_not_concrete(ci):
+                    self.rule_complemented_concrete(ass)
+                elif c_type == ConceptType.FUZZY_NUMBER:
+                    self.rule_fuzzy_number(ass)
+                elif OperatorConcept.is_not_fuzzy_number(ci):
+                    self.rule_complemented_fuzzy_number(ass)
+                elif c_type == ConceptType.MODIFIED:
+                    self.rule_modified(ass)
+                elif OperatorConcept.is_not_modified(ci):
+                    self.rule_complemented_modified(ass)
+                elif c_type == ConceptType.TOP:
+                    self.rule_top(ass)
+                elif c_type == ConceptType.BOTTOM:
+                    self.rule_bottom(ass)
+                elif c_type in (
+                    ConceptType.AT_MOST_VALUE,
+                    ConceptType.AT_LEAST_VALUE,
+                    ConceptType.EXACT_VALUE,
+                ):
+                    self.positive_concrete_value_assertions.append(ass)
+                elif (
+                    OperatorConcept.is_not_at_least_value(ci)
+                    or OperatorConcept.is_not_at_most_value(ci)
+                    or OperatorConcept.is_not_exact_value(ci)
+                ):
+                    self.add_negated_datatype_restriction(ass)
+                elif c_type == ConceptType.SELF:
+                    self.rule_self(ass)
+                elif OperatorConcept.is_not_self(ci):
+                    self.rule_complemented_self(ass)
+                elif c_type == ConceptType.UPPER_APPROX:
+                    self.rule_upper_approximation(ass)
+                elif c_type == ConceptType.TIGHT_UPPER_APPROX:
+                    self.rule_tight_upper_approximation(ass)
+                elif c_type == ConceptType.LOOSE_UPPER_APPROX:
+                    self.rule_loose_upper_approximation(ass)
+                elif c_type == ConceptType.LOWER_APPROX:
+                    self.rule_lower_approximation(ass)
+                elif c_type == ConceptType.TIGHT_LOWER_APPROX:
+                    self.rule_tight_lower_approximation(ass)
+                elif c_type == ConceptType.LOOSE_LOWER_APPROX:
+                    self.rule_loose_lower_approximation(ass)
+                elif c_type == ConceptType.GOEDEL_AND:
+                    self.rule_goedel_and(ass)
+                elif c_type == ConceptType.LUKASIEWICZ_AND:
+                    self.rule_lukasiewicz_and(ass)
+                elif c_type == ConceptType.GOEDEL_OR:
+                    self.rule_goedel_or(ass)
+                elif c_type == ConceptType.LUKASIEWICZ_OR:
+                    self.rule_lukasiewicz_or(ass)
+                elif c_type == ConceptType.GOEDEL_IMPLIES:
+                    self.rule_goedel_implication(ass)
+                elif OperatorConcept.is_not_goedel_implies(ci):
+                    self.rule_complemented_goedel_implication(ass)
+                elif c_type == ConceptType.ZADEH_IMPLIES:
+                    self.rule_zadeh_implication(ass)
+                elif OperatorConcept.is_not_zadeh_implies(ci):
+                    self.rule_complemented_zadeh_implication(ass)
+                elif c_type == ConceptType.W_SUM:
+                    self.rule_weighted_sum(ass)
+                elif OperatorConcept.is_not_weighted_sum(ci):
+                    self.rule_complemented_weighted_sum(ass)
+                elif c_type == ConceptType.W_SUM_ZERO:
+                    self.rule_weighted_sum_zero(ass)
+                elif OperatorConcept.is_not_weighted_sum_zero(ci):
+                    self.rule_complemented_weighted_sum_zero(ass)
+                elif c_type == ConceptType.WEIGHTED:
+                    self.rule_weighted_concept(ass)
+                elif OperatorConcept.is_not_weighted(ci):
+                    self.rule_complemented_weighted_concept(ass)
+                elif c_type == ConceptType.POS_THRESHOLD:
+                    self.rule_positive_threshold(ass)
+                elif OperatorConcept.is_not_pos_threshold(ci):
+                    self.rule_complemented_positive_threshold(ass)
+                elif c_type == ConceptType.NEG_THRESHOLD:
+                    self.rule_negative_threshold(ass)
+                elif OperatorConcept.is_not_neg_threshold(ci):
+                    self.rule_complemented_negative_threshold(ass)
+                elif c_type == ConceptType.EXT_POS_THRESHOLD:
+                    self.rule_extended_positive_threshold(ass)
+                elif OperatorConcept.is_not_ext_pos_threshold(ci):
+                    self.rule_complemented_extended_positive_threshold(ass)
+                elif c_type == ConceptType.EXT_NEG_THRESHOLD:
+                    self.rule_extended_negative_threshold(ass)
+                elif OperatorConcept.is_not_ext_neg_threshold(ci):
+                    self.rule_complemented_extended_negative_threshold(ass)
+                elif c_type == ConceptType.OWA:
+                    self.rule_owa(ass)
+                elif OperatorConcept.is_not_owa(ci):
+                    self.rule_complemented_owa(ass)
+                elif c_type == ConceptType.QUANTIFIED_OWA:
+                    self.rule_quantified_owa(ass)
+                elif OperatorConcept.is_not_qowa(ci):
+                    self.rule_complemented_quantified_owa(ass)
+                elif c_type == ConceptType.CHOQUET_INTEGRAL:
+                    self.rule_choquet(ass)
+                elif OperatorConcept.is_not_choquet(ci):
+                    self.rule_complemented_choquet(ass)
+                elif c_type == ConceptType.SUGENO_INTEGRAL:
+                    self.rule_sugeno(ass)
+                elif OperatorConcept.is_not_sugeno(ci):
+                    self.rule_complemented_sugeno(ass)
+                elif c_type == ConceptType.QUASI_SUGENO_INTEGRAL:
+                    self.rule_quasi_sugeno(ass)
+                elif OperatorConcept.is_not_quasi_sugeno(ci):
+                    self.rule_complemented_quasi_sugeno(ass)
+                elif c_type == ConceptType.W_MIN:
+                    self.rule_weighted_min(ass)
+                elif OperatorConcept.is_not_weighted_min(ci):
+                    self.rule_complemented_weighted_min(ass)
+                elif c_type == ConceptType.W_MAX:
+                    self.rule_weighted_max(ass)
+                elif OperatorConcept.is_not_weighted_max(ci):
+                    self.rule_complemented_weighted_max(ass)
                 else:
-                    self.get_correct_version_of_individual(ass)
-                    if ass.get_individual().is_blockable():
-                        Util.debug(
-                            f"Direct Blocking status {typing.cast(CreatedIndividual, ass.get_individual()).directly_blocked}"
-                        )
-                        Util.debug(
-                            f"Indirect Blocking status {typing.cast(CreatedIndividual, ass.get_individual()).indirectly_blocked}"
-                        )
-                    if (
-                        ass.get_individual().is_blockable()
-                        and CreatedIndividualHandler.is_indirectly_blocked(
-                            typing.cast(CreatedIndividual, ass.get_individual()), self
-                        )
-                    ):
-                        name: str = str(ass.get_individual())
-                        Util.debug(
-                            "Skipping assertion (it has an indirectly blocked individual)"
-                        )
-                        self.blocked_assertions[name] = self.blocked_assertions.get(
-                            name, []
-                        ) + [ass]
-                    else:
-                        self.milp.add_new_constraint(ass)
-                        if self.is_assertion_processed(ass):
-                            Util.debug(
-                                f"Assertion (without the degree): {ass} already processed."
-                            )
-                        else:
-                            ind: Individual = ass.get_individual()
-                            ci: Concept = ass.get_concept()
-                            self.add_negated_equations(ind, ci)
-                            c_type: ConceptType = ass.get_type()
-                            if c_type == ConceptType.ATOMIC:
-                                self.rule_atomic(ass)
-                            elif ci.is_complemented_atomic():
-                                self.rule_complemented_atomic(ass)
-                            elif c_type == ConceptType.AND:
-                                self.rule_and(ass)
-                            elif c_type == ConceptType.OR:
-                                self.rule_or(ass)
-                            elif c_type in (ConceptType.SOME, ConceptType.HAS_VALUE):
-                                self.exist_assertions.append(ass)
-                                continue
-                            elif c_type == ConceptType.ALL:
-                                self.rule_all(ass)
-                            elif OperatorConcept.is_not_has_value(ci):
-                                self.rule_complemented_has_value(ass)
-                            elif c_type == ConceptType.CONCRETE:
-                                self.rule_concrete(ass)
-                            elif OperatorConcept.is_not_concrete(ci):
-                                self.rule_complemented_concrete(ass)
-                            elif c_type == ConceptType.FUZZY_NUMBER:
-                                self.rule_fuzzy_number(ass)
-                            elif OperatorConcept.is_not_fuzzy_number(ci):
-                                self.rule_complemented_fuzzy_number(ass)
-                            elif c_type == ConceptType.MODIFIED:
-                                self.rule_modified(ass)
-                            elif OperatorConcept.is_not_modified(ci):
-                                self.rule_complemented_modified(ass)
-                            elif c_type == ConceptType.TOP:
-                                self.rule_top(ass)
-                            elif c_type == ConceptType.BOTTOM:
-                                self.rule_bottom(ass)
-                            elif c_type in (
-                                ConceptType.AT_MOST_VALUE,
-                                ConceptType.AT_LEAST_VALUE,
-                                ConceptType.EXACT_VALUE,
-                            ):
-                                self.positive_concrete_value_assertions.append(ass)
-                            elif (
-                                OperatorConcept.is_not_at_least_value(ci)
-                                or OperatorConcept.is_not_at_most_value(ci)
-                                or OperatorConcept.is_not_exact_value(ci)
-                            ):
-                                self.add_negated_datatype_restriction(ass)
-                            elif c_type == ConceptType.SELF:
-                                self.rule_self(ass)
-                            elif OperatorConcept.is_not_self(ci):
-                                self.rule_complemented_self(ass)
-                            elif c_type == ConceptType.UPPER_APPROX:
-                                self.rule_upper_approximation(ass)
-                            elif c_type == ConceptType.TIGHT_UPPER_APPROX:
-                                self.rule_tight_upper_approximation(ass)
-                            elif c_type == ConceptType.LOOSE_UPPER_APPROX:
-                                self.rule_loose_upper_approximation(ass)
-                            elif c_type == ConceptType.LOWER_APPROX:
-                                self.rule_lower_approximation(ass)
-                            elif c_type == ConceptType.TIGHT_LOWER_APPROX:
-                                self.rule_tight_lower_approximation(ass)
-                            elif c_type == ConceptType.LOOSE_LOWER_APPROX:
-                                self.rule_loose_lower_approximation(ass)
-                            elif c_type == ConceptType.GOEDEL_AND:
-                                self.rule_goedel_and(ass)
-                            elif c_type == ConceptType.LUKASIEWICZ_AND:
-                                self.rule_lukasiewicz_and(ass)
-                            elif c_type == ConceptType.GOEDEL_OR:
-                                self.rule_goedel_or(ass)
-                            elif c_type == ConceptType.LUKASIEWICZ_OR:
-                                self.rule_lukasiewicz_or(ass)
-                            elif c_type == ConceptType.GOEDEL_IMPLIES:
-                                self.rule_goedel_implication(ass)
-                            elif OperatorConcept.is_not_goedel_implies(ci):
-                                self.rule_complemented_goedel_implication(ass)
-                            elif c_type == ConceptType.ZADEH_IMPLIES:
-                                self.rule_zadeh_implication(ass)
-                            elif OperatorConcept.is_not_zadeh_implies(ci):
-                                self.rule_complemented_zadeh_implication(ass)
-                            elif c_type == ConceptType.W_SUM:
-                                self.rule_weighted_sum(ass)
-                            elif OperatorConcept.is_not_weighted_sum(ci):
-                                self.rule_complemented_weighted_sum(ass)
-                            elif c_type == ConceptType.W_SUM_ZERO:
-                                self.rule_weighted_sum_zero(ass)
-                            elif OperatorConcept.is_not_weighted_sum_zero(ci):
-                                self.rule_complemented_weighted_sum_zero(ass)
-                            elif c_type == ConceptType.WEIGHTED:
-                                self.rule_weighted_concept(ass)
-                            elif OperatorConcept.is_not_weighted(ci):
-                                self.rule_complemented_weighted_concept(ass)
-                            elif c_type == ConceptType.POS_THRESHOLD:
-                                self.rule_positive_threshold(ass)
-                            elif OperatorConcept.is_not_pos_threshold(ci):
-                                self.rule_complemented_positive_threshold(ass)
-                            elif c_type == ConceptType.NEG_THRESHOLD:
-                                self.rule_negative_threshold(ass)
-                            elif OperatorConcept.is_not_neg_threshold(ci):
-                                self.rule_complemented_negative_threshold(ass)
-                            elif c_type == ConceptType.EXT_POS_THRESHOLD:
-                                self.rule_extended_positive_threshold(ass)
-                            elif OperatorConcept.is_not_ext_pos_threshold(ci):
-                                self.rule_complemented_extended_positive_threshold(ass)
-                            elif c_type == ConceptType.EXT_NEG_THRESHOLD:
-                                self.rule_extended_negative_threshold(ass)
-                            elif OperatorConcept.is_not_ext_neg_threshold(ci):
-                                self.rule_complemented_extended_negative_threshold(ass)
-                            elif c_type == ConceptType.OWA:
-                                self.rule_owa(ass)
-                            elif OperatorConcept.is_not_owa(ci):
-                                self.rule_complemented_owa(ass)
-                            elif c_type == ConceptType.QUANTIFIED_OWA:
-                                self.rule_quantified_owa(ass)
-                            elif OperatorConcept.is_not_qowa(ci):
-                                self.rule_complemented_quantified_owa(ass)
-                            elif c_type == ConceptType.CHOQUET_INTEGRAL:
-                                self.rule_choquet(ass)
-                            elif OperatorConcept.is_not_choquet(ci):
-                                self.rule_complemented_choquet(ass)
-                            elif c_type == ConceptType.SUGENO_INTEGRAL:
-                                self.rule_sugeno(ass)
-                            elif OperatorConcept.is_not_sugeno(ci):
-                                self.rule_complemented_sugeno(ass)
-                            elif c_type == ConceptType.QUASI_SUGENO_INTEGRAL:
-                                self.rule_quasi_sugeno(ass)
-                            elif OperatorConcept.is_not_quasi_sugeno(ci):
-                                self.rule_complemented_quasi_sugeno(ass)
-                            elif c_type == ConceptType.W_MIN:
-                                self.rule_weighted_min(ass)
-                            elif OperatorConcept.is_not_weighted_min(ci):
-                                self.rule_complemented_weighted_min(ass)
-                            elif c_type == ConceptType.W_MAX:
-                                self.rule_weighted_max(ass)
-                            elif OperatorConcept.is_not_weighted_max(ci):
-                                self.rule_complemented_weighted_max(ass)
-                            else:
-                                Util.warning(f"Warning: Assertion with type {c_type}")
-                            nodes: set[str] = self.labels_with_nodes.get(str(ind))
-                            if nodes is not None:
-                                for node in nodes:
-                                    self.rule_ass_nom(ind, ci, node)
-                            self.mark_process_assertion(ass)
-                            ind.add_concept(ci)
-                            Util.debug(
-                                f"{constants.SEPARATOR}Assertion completed{constants.SEPARATOR}"
-                            )
+                    Util.warning(f"Warning: Assertion with type {c_type}")
+                # For each node in labelsWithNodes, apply AssNom rule
+                nodes: set[str] = self.labels_with_nodes.get(str(ind))
+                if nodes is not None:
+                    for node in nodes:
+                        self.rule_ass_nom(ind, ci, node)
+                self.mark_process_assertion(ass)
+                ind.add_concept(ci)
+                Util.debug(
+                    f"{constants.SEPARATOR}Assertion completed{constants.SEPARATOR}"
+                )
             self.assertions.clear()
+            # Solve one some rule
             if len(self.assertions) == 0:
                 self.solve_one_exist_assertion()
+            # Check if there are more assertions
             if len(self.assertions) == 0 and len(self.exist_assertions) == 0:
                 break
+        # Concrete assertions
         self.solve_concrete_value_assertions()
     def solve_concept_assertion(self, ind: Individual, concept: Concept) -> None:
@@ -3355,25 +3430,31 @@ class KnowledgeBase:
     def solve_concept_complemented_assertion(
         self, ind: Individual, lower_limit: Degree, concept: Concept
     ) -> None:
-        if isinstance(concept, ChoquetIntegral):
+        if OperatorConcept.is_not_choquet(concept):
             self.solve_choquet_integral_complemented_assertion(ind, concept)
-        elif isinstance(concept, (SugenoIntegral, QsugenoIntegral)):
+        elif OperatorConcept.is_not_sugeno(
+            concept
+        ) or OperatorConcept.is_not_quasi_sugeno(concept):
             self.solve_sugeno_integral_complemented_assertion(ind, concept)
-        elif isinstance(concept, (OwaConcept, QowaConcept)):
+        elif OperatorConcept.is_not_owa(concept) or OperatorConcept.is_not_qowa(
+            concept
+        ):
             self.solve_owa_complemented_assertion(ind, concept)
-        elif isinstance(concept, WeightedMaxConcept):
+        elif OperatorConcept.is_not_weighted_max(concept):
             self.solve_w_max_complemented_assertion(ind, concept)
-        elif isinstance(concept, WeightedMinConcept):
+        elif OperatorConcept.is_not_weighted_min(concept):
             self.solve_w_min_complemented_assertion(ind, concept)
-        elif isinstance(concept, WeightedSumConcept):
+        elif OperatorConcept.is_not_weighted_sum(concept):
             self.solve_w_sum_complemented_assertion(ind, concept)
-        elif isinstance(concept, WeightedSumZeroConcept):
+        elif OperatorConcept.is_not_weighted_sum_zero(concept):
             self.solve_w_sum_zero_complemented_assertion(ind, concept)
-        elif isinstance(concept, (ModifiedConcept, ModifiedConcreteConcept)):
-            self.solve_modifier_complemented_assertion(
-                ind, concept.curr_concept, lower_limit
-            )
-        elif isinstance(concept, FuzzyConcreteConcept):
+        elif isinstance(concept, OperatorConcept) and isinstance(
+            concept.get_atom(), (ModifiedConcept, ModifiedConcreteConcept)
+        ):
+            self.solve_modifier_complemented_assertion(ind, concept, lower_limit)
+        elif isinstance(concept, OperatorConcept) and isinstance(
+            concept.get_atom(), FuzzyConcreteConcept
+        ):
             self.solve_fuzzy_concrete_concept_complement_assertion(
                 ind, lower_limit, concept
             )
@@ -3417,12 +3498,15 @@ class KnowledgeBase:
         self.milp.add_new_constraint(exp, InequalityType.EQUAL, degree)
     def solve_choquet_integral_complemented_assertion(
-        self, ind: Individual, c: ChoquetIntegral
+        self, ind: Individual, c: OperatorConcept
     ) -> None:
-        n: int = len(c.concepts)
+        assert isinstance(c.get_atom(), ChoquetIntegral)
+        ci: ChoquetIntegral = c.get_atom()
+        n: int = len(ci.concepts)
         x: list[Variable] = [None] * n
         for i in range(n):
-            not_ci = -c.concepts[i]
+            not_ci = -ci.concepts[i]
             x[i] = self.milp.get_variable(ind, not_ci)
             self.add_assertion(ind, not_ci, DegreeVariable.get_degree(x[i]))
@@ -3433,9 +3517,9 @@ class KnowledgeBase:
         y: list[Variable] = self.milp.get_ordered_permutation(x, z)
         exp = Expression(1.0)
-        exp.add_term(Term(-c.weights[0], y[0]))
+        exp.add_term(Term(-ci.weights[0], y[0]))
         for k in range(1, n):
-            exp.add_term(Term(c.weights[k - 1] - c.weights[k], y[k]))
+            exp.add_term(Term(ci.weights[k - 1] - ci.weights[k], y[k]))
         degree: DegreeVariable = DegreeVariable.get_degree(
             self.milp.get_variable(ind, c)
@@ -3489,8 +3573,11 @@ class KnowledgeBase:
             self.milp.add_new_constraint(exp, InequalityType.EQUAL, degree)
     def solve_owa_complemented_assertion(
-        self, ind: Individual, c: typing.Union[OwaConcept, QowaConcept]
+        self, ind: Individual, curr_concept: OperatorConcept
     ) -> None:
+        assert isinstance(curr_concept.get_atom(), (OwaConcept, QowaConcept))
+        c: typing.Union[OwaConcept, QowaConcept] = curr_concept.get_atom()
         x_A_in_not_WS: Variable = self.milp.get_variable(ind, c)
         n: int = len(c.concepts)
         x: list[Variable] = []
@@ -3509,7 +3596,7 @@ class KnowledgeBase:
         for j in range(n):
             exp.add_term(Term(-c.weights[j], y[j]))
         self.milp.add_new_constraint(exp, InequalityType.EQUAL)
-        self.rule_complemented(ind, c)
+        self.rule_complemented(ind, curr_concept)
     def solve_sugeno_integral_assertion(
         self, ind: Individual, concept: typing.Union[SugenoIntegral, QsugenoIntegral]
@@ -3561,12 +3648,12 @@ class KnowledgeBase:
             self.milp.get_new_variable(VariableType.SEMI_CONTINUOUS) for _ in range(n)
         ]
-        if isinstance(concept, SugenoIntegral):
-            for i in range(n):
-                ZadehSolver.and_equation(c[i], y[i], a[i], self.milp)
-        elif isinstance(concept, QsugenoIntegral):
+        if isinstance(concept, QsugenoIntegral):
             for i in range(n):
                 LukasiewiczSolver.and_equation(c[i], y[i], a[i], self.milp)
+        elif isinstance(concept, SugenoIntegral):
+            for i in range(n):
+                ZadehSolver.and_equation(c[i], y[i], a[i], self.milp)
         degree: DegreeVariable = DegreeVariable.get_degree(
             self.milp.get_variable(ind, concept)
@@ -3587,8 +3674,11 @@ class KnowledgeBase:
         self.milp.add_new_constraint(exp, InequalityType.EQUAL, n - 1)
     def solve_sugeno_integral_complemented_assertion(
-        self, ind: Individual, concept: typing.Union[SugenoIntegral, QsugenoIntegral]
+        self, ind: Individual, curr_concept: OperatorConcept
     ) -> None:
+        assert isinstance(curr_concept.get_atom(), (SugenoIntegral, QsugenoIntegral))
+        concept: typing.Union[SugenoIntegral, QsugenoIntegral] = curr_concept.get_atom()
         n: int = len(concept.concepts)
         x: list[Variable] = []
         for i in range(n):
@@ -3638,15 +3728,15 @@ class KnowledgeBase:
             self.milp.get_new_variable(VariableType.SEMI_CONTINUOUS) for _ in range(n)
         ]
-        if isinstance(concept, SugenoIntegral):
-            for i in range(n):
-                ZadehSolver.and_equation(c[i], y[i], a[i], self.milp)
-        elif isinstance(concept, QsugenoIntegral):
+        if isinstance(concept, QsugenoIntegral):
             for i in range(n):
                 LukasiewiczSolver.and_equation(c[i], y[i], a[i], self.milp)
+        elif isinstance(concept, SugenoIntegral):
+            for i in range(n):
+                ZadehSolver.and_equation(c[i], y[i], a[i], self.milp)
         degree: DegreeVariable = DegreeVariable.get_degree(
-            self.milp.get_variable(ind, concept)
+            self.milp.get_variable(ind, curr_concept)
         )
         b: list[Variable] = [
             self.milp.get_new_variable(VariableType.BINARY) for _ in range(n)
@@ -3662,7 +3752,7 @@ class KnowledgeBase:
         for i in range(n):
             exp.add_term(Term(1.0, b[i]))
         self.milp.add_new_constraint(exp, InequalityType.EQUAL, n - 1)
-        self.rule_complemented(ind, concept)
+        self.rule_complemented(ind, curr_concept)
     def solve_w_max_assertion(
         self, ind: Individual, concept: WeightedMaxConcept
@@ -3678,9 +3768,12 @@ class KnowledgeBase:
         ZadehSolver.or_equation(min_vars, x_A_in_WS, self.milp)
     def solve_w_max_complemented_assertion(
-        self, ind: Individual, concept: WeightedMaxConcept
+        self, ind: Individual, curr_concept: OperatorConcept
     ) -> None:
-        x_A_in_WS: Variable = self.milp.get_variable(ind, concept)
+        assert isinstance(curr_concept.get_atom(), WeightedMaxConcept)
+        concept: WeightedMaxConcept = curr_concept.get_atom()
+        x_A_in_WS: Variable = self.milp.get_variable(ind, curr_concept)
         negmin: list[Variable] = []
         for ci, weight in zip(concept.concepts, concept.weights):
             not_ci: Concept = -ci
@@ -3691,7 +3784,7 @@ class KnowledgeBase:
             ZadehSolver.or_negated_equation(max_var, xi, 1.0 - weight, self.milp)
             negmin.append(max_var)
         ZadehSolver.and_equation(negmin, x_A_in_WS, self.milp)
-        self.rule_complemented(ind, concept)
+        self.rule_complemented(ind, curr_concept)
     def solve_w_min_assertion(
         self, ind: Individual, concept: WeightedMinConcept
@@ -3707,9 +3800,12 @@ class KnowledgeBase:
         ZadehSolver.and_equation(max_vars, x_A_in_WS, self.milp)
     def solve_w_min_complemented_assertion(
-        self, ind: Individual, concept: WeightedMinConcept
+        self, ind: Individual, curr_concept: OperatorConcept
     ) -> None:
-        x_A_in_WS: Variable = self.milp.get_variable(ind, concept)
+        assert isinstance(curr_concept.get_atom(), WeightedMinConcept)
+        concept: WeightedMinConcept = curr_concept.get_atom()
+        x_A_in_WS: Variable = self.milp.get_variable(ind, curr_concept)
         negmax: list[Variable] = []
         for ci, weight in zip(concept.concepts, concept.weights):
             not_ci: Concept = -ci
@@ -3720,7 +3816,7 @@ class KnowledgeBase:
             ZadehSolver.and_negated_equation(max_var, xi, weight, self.milp)
             negmax.append(max_var)
         ZadehSolver.or_equation(negmax, x_A_in_WS, self.milp)
-        self.rule_complemented(ind, concept)
+        self.rule_complemented(ind, curr_concept)
     def solve_w_sum_assertion(
         self, ind: Individual, concept: WeightedSumConcept
@@ -3738,9 +3834,12 @@ class KnowledgeBase:
         )
     def solve_w_sum_complemented_assertion(
-        self, ind: Individual, concept: WeightedSumConcept
+        self, ind: Individual, curr_concept: OperatorConcept
     ) -> None:
-        x_A_in_not_WS: Variable = self.milp.get_variable(ind, concept)
+        assert isinstance(curr_concept.get_atom(), WeightedSumConcept)
+        concept: WeightedSumConcept = curr_concept.get_atom()
+        x_A_in_not_WS: Variable = self.milp.get_variable(ind, curr_concept)
         terms: list[Term] = []
         for ci, weight in zip(concept.concepts, concept.weights):
             not_ci: Concept = -ci
@@ -3753,7 +3852,7 @@ class KnowledgeBase:
             InequalityType.EQUAL,
             DegreeVariable.get_degree(x_A_in_not_WS),
         )
-        self.rule_complemented(ind, concept)
+        self.rule_complemented(ind, curr_concept)
     def solve_w_sum_zero_assertion(
         self, ind: Individual, concept: WeightedSumZeroConcept
@@ -3787,11 +3886,14 @@ class KnowledgeBase:
         self.rule_complemented(ind, concept)
     def solve_w_sum_zero_complemented_assertion(
-        self, ind: Individual, concept: WeightedSumZeroConcept
+        self, ind: Individual, curr_concept: OperatorConcept
     ) -> None:
+        assert isinstance(curr_concept.get_atom(), WeightedSumZeroConcept)
+        concept: WeightedSumZeroConcept = curr_concept.get_atom()
         terms: list[Term] = []
         vx: list[Variable] = []
-        x_A_in_not_ws: Variable = self.milp.get_variable(ind, concept)
+        x_A_in_not_ws: Variable = self.milp.get_variable(ind, curr_concept)
         y: Variable = self.milp.get_new_variable(VariableType.BINARY)
         z: Variable = self.milp.get_new_variable(VariableType.SEMI_CONTINUOUS)
         for ci, weight in zip(concept.concepts, concept.weights):
@@ -3814,7 +3916,7 @@ class KnowledgeBase:
         exp2: Expression = Expression(*terms)
         exp2.add_term(Term(1.0, y))
         self.milp.add_new_constraint(exp2, InequalityType.GREATER_THAN)
-        self.rule_complemented(ind, concept)
+        self.rule_complemented(ind, curr_concept)
     def solve_crisp_concrete_concept_assertion(
         self, ind: Individual, concept: CrispConcreteConcept
@@ -3888,10 +3990,11 @@ class KnowledgeBase:
         self,
         ind: CreatedIndividual,
         lower_limit: Degree,
-        concept: FuzzyConcreteConcept,
+        curr_concept: OperatorConcept,
     ) -> None:
         """Solve a complement assertion"""
-        assertion: Assertion = Assertion(ind, -concept, lower_limit)
+        assert isinstance(curr_concept.get_atom(), FuzzyConcreteConcept)
+        assertion: Assertion = Assertion(ind, curr_concept, lower_limit)
         self.rule_complemented_complex_assertion(assertion)
     def solve_left_concrete_concept_assertion(
@@ -4264,9 +4367,12 @@ class KnowledgeBase:
         )
     def solve_modifier_complemented_assertion(
-        self, ind: Individual, con: Concept, degree: Degree
+        self, ind: Individual, concept: OperatorConcept, degree: Degree
     ) -> None:
-        ass: Assertion = Assertion(ind, -con, degree)
+        assert isinstance(concept, OperatorConcept) and isinstance(
+            concept.get_atom(), (ModifiedConcept, ModifiedConcreteConcept)
+        )
+        ass: Assertion = Assertion(ind, concept, degree)
         self.rule_complemented_complex_assertion(ass)
     def solve_linear_modifier_assertion(
@@ -4434,7 +4540,9 @@ class KnowledgeBase:
     def add_negated_datatype_restriction(self, ass: Assertion) -> None:
         a: Individual = ass.get_individual()
-        c: Concept = ass.get_concept()
+        op: Concept = ass.get_concept()
+        assert isinstance(op, OperatorConcept) and op.type == ConceptType.COMPLEMENT
+        c: Concept = op.get_atom()
         assert isinstance(c, HasRoleInterface)
         f_name: str = c.role
         a.add_concrete_restriction(f_name, ass)
@@ -5372,7 +5480,7 @@ class KnowledgeBase:
         self.compute_variables_old_calculus(fcc)
         ind: CreatedIndividual = typing.cast(CreatedIndividual, ass.get_individual())
-        self.solve_concept_complemented_assertion(ind, ass.get_lower_limit(), fcc)
+        self.solve_concept_complemented_assertion(ind, ass.get_lower_limit(), c)
         # fcc.solve_complement_assertion(ind, ass.get_lower_limit(), self)
     def rule_fuzzy_number(self, ass: Assertion) -> None:
@@ -5413,7 +5521,7 @@ class KnowledgeBase:
         #     ass.get_individual(), ass.get_lower_limit(), self
         # )
         self.solve_modifier_complemented_assertion(
-            ass.get_individual(), mod, ass.get_lower_limit()
+            ass.get_individual(), c, ass.get_lower_limit()
         )
     def rule_bottom(self, ass: Assertion) -> None:
@@ -5786,7 +5894,7 @@ class KnowledgeBase:
         self.milp.add_new_constraint(
             Expression(Term(1.0, x_a_in_wc), Term(-w, x_a_in_c)), InequalityType.EQUAL
         )
-        self.rule_complemented(i, wc)
+        self.rule_complemented(i, c)
     def rule_complemented_complex_assertion(self, ass: Assertion) -> None:
         i: Individual = ass.get_individual()
@@ -5818,12 +5926,13 @@ class KnowledgeBase:
         c: Concept = ass.get_concept()
         assert isinstance(c, OperatorConcept)
         ws: WeightedSumConcept = typing.cast(WeightedSumConcept, c.get_atom())
         n: int = len(ws.concepts)
         self.old_01_variables += n
         self.rules_applied[KnowledgeBaseRules.RULE_NOT_W_SUM] += 1
         # ws.solve_complemented_assertion(ass.get_individual(), self)
-        self.solve_concept_complemented_assertion(ass.get_individual(), None, ws)
+        self.solve_concept_complemented_assertion(ass.get_individual(), None, c)
     def rule_weighted_sum_zero(self, ass: Assertion) -> None:
         n: int = len(typing.cast(WeightedSumZeroConcept, ass.get_concept()).concepts)
@@ -5839,11 +5948,11 @@ class KnowledgeBase:
     def rule_complemented_weighted_sum_zero(self, ass: Assertion) -> None:
         c: Concept = ass.get_concept()
         assert isinstance(c, OperatorConcept)
-        wsz: WeightedSumZeroConcept = typing.cast(WeightedSumZeroConcept, c.get_atom())
+        assert isinstance(c.get_atom(), WeightedSumZeroConcept)
         self.rules_applied[KnowledgeBaseRules.RULE_NOT_W_SUM_ZERO] += 1
         # wsz.solve_complemented_assertion(ass.get_individual(), self)
-        self.solve_concept_complemented_assertion(ass.get_individual(), None, wsz)
+        self.solve_concept_complemented_assertion(ass.get_individual(), None, c)
     def rule_weighted_min(self, ass: Assertion) -> None:
         self.rules_applied[KnowledgeBaseRules.RULE_W_MIN] += 1
@@ -5857,11 +5966,11 @@ class KnowledgeBase:
     def rule_complemented_weighted_min(self, ass: Assertion) -> None:
         c: Concept = ass.get_concept()
         assert isinstance(c, OperatorConcept)
-        wm: WeightedMinConcept = typing.cast(WeightedMinConcept, c.get_atom())
+        assert isinstance(c.get_atom(), WeightedMinConcept)
         self.rules_applied[KnowledgeBaseRules.RULE_NOT_W_MIN] += 1
         # wm.solve_complemented_assertion(ass.get_individual(), self)
-        self.solve_concept_complemented_assertion(ass.get_individual(), None, wm)
+        self.solve_concept_complemented_assertion(ass.get_individual(), None, c)
     def rule_weighted_max(self, ass: Assertion) -> None:
         self.rules_applied[KnowledgeBaseRules.RULE_W_MAX] += 1
@@ -5875,11 +5984,11 @@ class KnowledgeBase:
     def rule_complemented_weighted_max(self, ass: Assertion) -> None:
         c: Concept = ass.get_concept()
         assert isinstance(c, OperatorConcept)
-        wm: WeightedMaxConcept = typing.cast(WeightedMaxConcept, c.get_atom())
+        assert isinstance(c.get_atom(), WeightedMaxConcept)
         self.rules_applied[KnowledgeBaseRules.RULE_NOT_W_MAX] += 1
         # wm.solve_complemented_assertion(ass.get_individual(), self)
-        self.solve_concept_complemented_assertion(ass.get_individual(), None, wm)
+        self.solve_concept_complemented_assertion(ass.get_individual(), None, c)
     def rule_owa(self, ass: Assertion) -> None:
         n: int = len(typing.cast(OwaConcept, ass.get_concept()).concepts)
@@ -5904,7 +6013,7 @@ class KnowledgeBase:
         self.rules_applied[KnowledgeBaseRules.RULE_NOT_OWA] += 1
         # oc.solve_complemented_assertion(ass.get_individual(), self)
-        self.solve_concept_complemented_assertion(ass.get_individual(), None, oc)
+        self.solve_concept_complemented_assertion(ass.get_individual(), None, c)
     def rule_quantified_owa(self, ass: Assertion) -> None:
         self.rules_applied[KnowledgeBaseRules.RULE_OWA] += 1
@@ -5932,12 +6041,12 @@ class KnowledgeBase:
     def rule_complemented_choquet(self, ass: Assertion) -> None:
         c: Concept = ass.get_concept()
         assert isinstance(c, OperatorConcept)
-        ci: ChoquetIntegral = typing.cast(ChoquetIntegral, c.get_atom())
+        assert isinstance(c.get_atom(), ChoquetIntegral)
         self.rules_applied[KnowledgeBaseRules.RULE_NOT_CHOQUET_INTEGRAL] += 1
         # ci.solve_complemented_assertion(ass.get_individual(), self)
-        self.solve_concept_complemented_assertion(ass.get_individual(), None, ci)
+        self.solve_concept_complemented_assertion(ass.get_individual(), None, c)
     def rule_sugeno(self, ass: Assertion) -> None:
         self.rules_applied[KnowledgeBaseRules.RULE_SUGENO_INTEGRAL] += 1
@@ -5951,11 +6060,11 @@ class KnowledgeBase:
     def rule_complemented_sugeno(self, ass: Assertion) -> None:
         c: Concept = ass.get_concept()
         assert isinstance(c, OperatorConcept)
-        si: SugenoIntegral = typing.cast(SugenoIntegral, c.get_atom())
+        assert isinstance(c.get_atom(), SugenoIntegral)
         self.rules_applied[KnowledgeBaseRules.RULE_NOT_SUGENO_INTEGRAL] += 1
         # si.solve_complemented_assertion(ass.get_individual(), self)
-        self.solve_concept_complemented_assertion(ass.get_individual(), None, si)
+        self.solve_concept_complemented_assertion(ass.get_individual(), None, c)
     def rule_quasi_sugeno(self, ass: Assertion) -> None:
         self.rules_applied[KnowledgeBaseRules.RULE_QUASI_SUGENO_INTEGRAL] += 1
@@ -5969,11 +6078,11 @@ class KnowledgeBase:
     def rule_complemented_quasi_sugeno(self, ass: Assertion) -> None:
         c: Concept = ass.get_concept()
         assert isinstance(c, OperatorConcept)
-        qsi: QsugenoIntegral = typing.cast(QsugenoIntegral, c.get_atom())
+        assert isinstance(c.get_atom(), QsugenoIntegral)
         self.rules_applied[KnowledgeBaseRules.RULE_NOT_QUASI_SUGENO_INTEGRAL] += 1
         # qsi.solve_complemented_assertion(ass.get_individual(), self)
-        self.solve_concept_complemented_assertion(ass.get_individual(), None, qsi)
+        self.solve_concept_complemented_assertion(ass.get_individual(), None, c)
     def rule_complemented_at_most_datatype_restriction(
         self, b: CreatedIndividual, ass: Assertion
@@ -6002,9 +6111,6 @@ class KnowledgeBase:
     def set_dynamic_blocking(self) -> None:
         self.blocking_dynamic = True
-    def get_version(self) -> float:
-        return KnowledgeBase.VERSION
     def is_crisp_role(self, role_name: str) -> bool:
         return (
             constants.KNOWLEDGE_BASE_SEMANTICS == FuzzyLogic.CLASSICAL
@@ -6216,6 +6322,7 @@ class KnowledgeBase:
         Util.debug(f"{constants.STAR_SEPARATOR * 2}")
+@class_debugging()
 class DatatypeReasoner:
     @staticmethod
@@ -6256,7 +6363,7 @@ class DatatypeReasoner:
                 ind, role, b, DegreeVariable.get_degree(x_f), kb
             )
         x_b: Variable = DatatypeReasoner.get_xb(b, t, kb)
-        if new_variable is not None and k is not None:
+        if new_variable and k is not None:
             kb.restrict_range(x_b, x_f, k[0], k[1])
         return [b, x_b, x_f]
@@ -6495,7 +6602,7 @@ class DatatypeReasoner:
                 n, kb, x_b, x_is_c, x_f, k, InequalityType.LESS_THAN
             )
         elif type == InequalityType.GREATER_THAN:
-            if isinstance(n, float):
+            if isinstance(n, constants.NUMBER):
                 kb.milp.add_new_constraint(
                     Expression(
                         constants.MAXVAL,
@@ -6524,7 +6631,7 @@ class DatatypeReasoner:
                     InequalityType.GREATER_THAN,
                 )
         elif type == InequalityType.LESS_THAN:
-            if isinstance(n, float):
+            if isinstance(n, constants.NUMBER):
                 kb.milp.add_new_constraint(
                     Expression(
                         -constants.MAXVAL,
@@ -6564,7 +6671,7 @@ class DatatypeReasoner:
         t: ConcreteFeature = DatatypeReasoner.get_feature(f_name, kb)
         k: typing.Optional[list[float]] = DatatypeReasoner.get_bounds(t)
         return_value: list[typing.Any] = (
-            DatatypeReasoner.get_created_individual_and_variables(a, c.role, t, k, kb)
+            DatatypeReasoner.get_created_individual_and_variables(a, f_name, t, k, kb)
         )
         b: CreatedIndividual = typing.cast(CreatedIndividual, return_value[0])
         x_b: Variable = typing.cast(Variable, return_value[1])
@@ -6647,7 +6754,8 @@ class DatatypeReasoner:
         type: InequalityType,
     ) -> None:
         if type == InequalityType.GREATER_THAN:
-            if isinstance(n, float):
+            if isinstance(n, constants.NUMBER):
+                # x_b <= (n - \epsilon) + (2 k_\infty + \epsilon) (1 - x_f) + (2k_\infty + \epsilon) x_is_c
                 kb.milp.add_new_constraint(
                     Expression(
                         constants.MAXVAL2 + n,
@@ -6658,6 +6766,7 @@ class DatatypeReasoner:
                     InequalityType.GREATER_THAN,
                 )
             elif isinstance(n, Variable):
+                # x_b <= x - \epsilon x_f + 2k_\infty (1 - x_f) + (2k_\infty + \epsilon) x_is_c
                 kb.milp.add_new_constraint(
                     Expression(
                         constants.MAXVAL2,
@@ -6668,16 +6777,19 @@ class DatatypeReasoner:
                     ),
                     InequalityType.GREATER_THAN,
                 )
+                # x \geq -max_val
                 kb.milp.add_new_constraint(
                     Expression(constants.MAXVAL, Term(1.0, n)),
                     InequalityType.GREATER_THAN,
                 )
+                # x \leq max_val
                 kb.milp.add_new_constraint(
                     Expression(constants.MAXVAL, Term(-1.0, n)),
                     InequalityType.GREATER_THAN,
                 )
         elif type == InequalityType.LESS_THAN:
-            if isinstance(n, float):
+            if isinstance(n, constants.NUMBER):
+                # x_b >= (n + \epsilon) - (2 k_\infty + \epsilon) (1 - x_f) - (2k_\infty + \epsilon) x_is_c
                 kb.milp.add_new_constraint(
                     Expression(
                         -constants.MAXVAL2 + n,
@@ -6688,6 +6800,7 @@ class DatatypeReasoner:
                     InequalityType.LESS_THAN,
                 )
             elif isinstance(n, Variable):
+                # x_b >= x + \epsilon x_f - 2k_\infty (1 - x_f) - (2k_\infty + \epsilon) x_is_c
                 kb.milp.add_new_constraint(
                     Expression(
                         -constants.MAXVAL2,
@@ -6698,16 +6811,19 @@ class DatatypeReasoner:
                     ),
                     InequalityType.LESS_THAN,
                 )
+                # x \geq -max_val
                 kb.milp.add_new_constraint(
                     Expression(constants.MAXVAL, Term(1.0, n)),
                     InequalityType.GREATER_THAN,
                 )
+                # x \leq max_val
                 kb.milp.add_new_constraint(
                     Expression(constants.MAXVAL, Term(-1.0, n)),
                     InequalityType.GREATER_THAN,
                 )
         elif type == InequalityType.EQUAL:
-            if isinstance(n, float):
+            if isinstance(n, constants.NUMBER):
+                # x_b <= (n - \epsilon) y + k_\infty (1 - y) + (2 k_\infty + \epsilon) (1 - x_f) + (2k_\infty + \epsilon) x_is_c
                 y: Variable = kb.milp.get_new_variable(VariableType.BINARY)
                 kb.milp.add_new_constraint(
                     Expression(
@@ -6719,6 +6835,7 @@ class DatatypeReasoner:
                     ),
                     InequalityType.GREATER_THAN,
                 )
+                # x_b >= (n + \epsilon) (1 - y) - k_\infty y - (2 k_\infty + \epsilon) (1 - x_f) - (2k_\infty + \epsilon) x_is_c
                 kb.milp.add_new_constraint(
                     Expression(
                         -constants.MAXVAL2 + n,
@@ -6730,10 +6847,11 @@ class DatatypeReasoner:
                     InequalityType.LESS_THAN,
                 )
             elif isinstance(n, Variable):
+                # x_b <= x - \epsilon x_f + (2k_\infty + \epsilon) (1 - y) + 2k_\infty (1 - x_f) + (2k_\infty + \epsilon) x_is_c
                 y: Variable = kb.milp.get_new_variable(VariableType.BINARY)
                 kb.milp.add_new_constraint(
                     Expression(
-                        2 * constants.MAXVAL2 + ConfigReader.EPSILON,
+                        4 * constants.MAXVAL + ConfigReader.EPSILON,
                         Term(constants.MAXVAL + n + ConfigReader.EPSILON, y),
                         Term(-1.0, x_b),
                         Term(1.0, n),
@@ -6742,6 +6860,7 @@ class DatatypeReasoner:
                     ),
                     InequalityType.GREATER_THAN,
                 )
+                # x_b >= x + \epsilon x_f - (2k_\infty + \epsilon) y - 2k_\infty (1 - x_f) - (2k_\infty + \epsilon) x_is_c
                 kb.milp.add_new_constraint(
                     Expression(
                         -constants.MAXVAL2,
@@ -6753,10 +6872,12 @@ class DatatypeReasoner:
                     ),
                     InequalityType.LESS_THAN,
                 )
+                # x \geq -maxval
                 kb.milp.add_new_constraint(
                     Expression(constants.MAXVAL, Term(1.0, n)),
                     InequalityType.GREATER_THAN,
                 )
+                # x \leq maxval
                 kb.milp.add_new_constraint(
                     Expression(constants.MAXVAL, Term(-1.0, n)),
                     InequalityType.GREATER_THAN,
@@ -6920,27 +7041,23 @@ class DatatypeReasoner:
         b: CreatedIndividual, ass: Assertion, kb: KnowledgeBase, type: InequalityType
     ) -> None:
         a: Individual = ass.get_individual()
+        not_c: Concept = ass.get_concept()
+        assert isinstance(not_c, OperatorConcept)
+        c: Concept = not_c.get_atom()
+        assert isinstance(c, HasValueInterface)
-        c: Concept = ass.get_concept()
-        assert isinstance(c, OperatorConcept)
-        not_c: Concept = c.get_atom()
-        assert isinstance(not_c, HasValueInterface)
-        f_name: str = not_c.role
+        f_name: str = c.role
         t: ConcreteFeature = DatatypeReasoner.get_feature(f_name, kb)
         k: typing.Optional[list[float]] = DatatypeReasoner.get_bounds(t)
         return_value: list[typing.Any] = (
-            DatatypeReasoner.get_created_individual_and_variables(
-                a, not_c.role, t, k, kb
-            )
+            DatatypeReasoner.get_created_individual_and_variables(a, f_name, t, k, kb)
         )
         x_f: Variable = typing.cast(Variable, return_value[2])
         x_is_not_c: Variable = kb.milp.get_variable(ass)
         kb.old_binary_variables += 1
         x_f.set_binary_variable()
         x_b: Variable = DatatypeReasoner.get_xb(b, t, kb)
-        c: Concept = -not_c
+        # c: Concept = -not_c
         x_is_c: Variable = kb.milp.get_variable(a, c)
         x_b.set_datatype_filler_variable()
         kb.milp.add_new_constraint(
@@ -6972,6 +7089,7 @@ class DatatypeReasoner:
             x_is_not_c.set_binary_variable()
             x_is_c.set_binary_variable()
             if isinstance(n, FeatureFunction):
+                # If n is a FeatureFunction, check that there exist fillers
                 fun: FeatureFunction = typing.cast(FeatureFunction, n)
                 array: set[str] = fun.get_features()
                 for feature in array:
@@ -7026,6 +7144,7 @@ class DatatypeReasoner:
         DatatypeReasoner.apply_not_rule(b, ass, kb, InequalityType.EQUAL)
+@class_debugging()
 class LukasiewiczSolver:
     @staticmethod
     def solve_and(ass: Assertion, kb: KnowledgeBase) -> None:
@@ -7352,6 +7471,7 @@ class LukasiewiczSolver:
         milp.add_new_constraint(exp2, InequalityType.LESS_THAN)
+@class_debugging()
 class ZadehSolver:
     @staticmethod
@@ -7849,14 +7969,12 @@ class ZadehSolver:
         else:
             assert isinstance(args[0], Variable)
             assert isinstance(args[1], Variable)
-            assert isinstance(args[2], Variable)
+            assert isinstance(args[2], constants.NUMBER)
             assert isinstance(args[3], MILPHelper)
             ZadehSolver.__or_equation_1(*args)
     @staticmethod
-    def __or_equation_1(
-        z: Variable, x1: Variable, x2: Variable, milp: MILPHelper
-    ) -> None:
+    def __or_equation_1(z: Variable, x1: Variable, x2: float, milp: MILPHelper) -> None:
         y: Variable = milp.get_new_variable(VariableType.BINARY)
         milp.add_new_constraint(
             Expression(Term(1.0, z), Term(-1.0, x1)), InequalityType.GREATER_THAN
@@ -7936,6 +8054,7 @@ class ZadehSolver:
         return n1
+@class_debugging()
 class ClassicalSolver:
     @staticmethod
     def solve_and(ass: Assertion, kb: KnowledgeBase) -> None:
@@ -7954,6 +8073,7 @@ class ClassicalSolver:
         ZadehSolver.solve_all(rel, restrict, kb)
+@class_debugging()
 class IndividualHandler:
     @staticmethod
@@ -8134,6 +8254,7 @@ class IndividualHandler:
                 return
+@class_debugging()
 class CreatedIndividualHandler:
     @staticmethod
@@ -8167,16 +8288,22 @@ class CreatedIndividualHandler:
     def unblock_pairwise(
         current_individual: CreatedIndividual, kb: KnowledgeBase
     ) -> None:
+        """
+        Unblock the individual
+        """
         Util.debug(f"Test of Pair-wise Unblock children of {current_individual.name}")
+        # "current_individual" is a blocking Y node: unblock blocked nodes
         if current_individual.name in kb.directly_blocked_children:
             Util.debug(f"{current_individual.name} is a blocking Y node")
+            # remove Y from the Yprime list
             y_prime: CreatedIndividual = typing.cast(
                 CreatedIndividual,
                 typing.cast(CreatedIndividual, current_individual).parent,
             )
             y_individuals: list[str] = kb.y_prime_individuals.get(str(y_prime), [])
-            del y_individuals[current_individual.name]
+            y_individuals.remove(current_individual.name)
+            # update Xprime list
             if len(y_individuals) > 0:
                 kb.y_prime_individuals[str(y_prime)] = y_individuals
             else:
@@ -8184,6 +8311,7 @@ class CreatedIndividualHandler:
             for x_name in kb.directly_blocked_children.get(current_individual.name):
                 Util.debug(f"Processing X node {x_name}")
+                # remove Xname from the  Xprime list
                 x: CreatedIndividual = typing.cast(
                     CreatedIndividual, kb.individuals.get(x_name)
                 )
@@ -8191,22 +8319,25 @@ class CreatedIndividualHandler:
                     CreatedIndividual, x.get_parent()
                 )
                 x_individuals: list[str] = kb.x_prime_individuals.get(str(x_prime), [])
-                del x_individuals[current_individual.name]
+                x_individuals.remove(x_name)
                 if len(x_individuals) > 0:
                     kb.x_prime_individuals[str(x_prime)] = x_individuals
                 else:
                     del kb.x_prime_individuals[str(x_prime)]
+                # at last, unblock
                 kb.unblock_individual(x_name)
+            # now, Y (= current_individual) cannot be a blocking node anymore
             del kb.directly_blocked_children[current_individual.name]
+        # if "current_individual" is a Yprime node: unblock blocking Y nodes
         if current_individual.name in kb.y_prime_individuals:
             Util.debug(f"{current_individual.name} is a y_prime node")
             for y_name in kb.y_prime_individuals.get(current_individual.name):
                 Util.debug(f"Processing Y node {y_name}")
                 for x_name in kb.directly_blocked_children.get(y_name):
                     Util.debug(f"Processing X node {x_name}")
+                    # remove X from the  Xprime list
                     x: CreatedIndividual = typing.cast(
                         CreatedIndividual, kb.individuals.get(x_name)
                     )
@@ -8219,17 +8350,19 @@ class CreatedIndividualHandler:
                         x_individuals: list[str] = kb.x_prime_individuals.get(
                             str(x_prime), []
                         )
-                        del x_individuals[current_individual.name]
+                        x_individuals.remove(x_name)
                         if len(x_individuals) > 0:
                             kb.x_prime_individuals[str(x_prime)] = x_individuals
                         else:
                             del kb.x_prime_individuals[str(x_prime)]
+                    # unblock X
                     kb.unblock_individual(x_name)
+                # now, Yname cannot be a blocking node anymore
                 del kb.directly_blocked_children[y_name]
+            # now, remove Yprime from the Yprime list
             del kb.y_prime_individuals[current_individual.name]
+        # if "current_individual" is a Xprime node: unblock blocked X nodes
         if current_individual.name in kb.x_prime_individuals:
             Util.debug(f"{current_individual.name} is a x_prime node")
             x_individuals: list[str] = kb.x_prime_individuals.get(
@@ -8237,6 +8370,7 @@ class CreatedIndividualHandler:
             )
             for x_name in x_individuals:
                 Util.debug(f"Processing X node {x_name}")
+                # remove X from the  directlyBlockedChildren list
                 x: CreatedIndividual = typing.cast(
                     CreatedIndividual, kb.individuals.get(x_name)
                 )
@@ -8246,26 +8380,28 @@ class CreatedIndividualHandler:
                         CreatedIndividual, kb.individuals.get(y_name)
                     )
                     blocked_by_y: list[str] = kb.directly_blocked_children[y_name]
-                    del blocked_by_y[x_name]
+                    blocked_by_y.remove(x_name)
                     if len(blocked_by_y) > 0:
                         kb.directly_blocked_children[y_name] = blocked_by_y
                     else:
                         del kb.directly_blocked_children[y_name]
+                        # update Yprime list
                         y_prime: CreatedIndividual = typing.cast(
                             CreatedIndividual, y.get_parent()
                         )
                         y_individuals: list[str] = kb.x_prime_individuals.get(
                             str(y_prime)
                         )
-                        del y_individuals[y_name]
+                        y_individuals.remove(y_name)
                         if len(y_individuals) > 0:
                             kb.y_prime_individuals[str(y_prime)] = x_individuals
                         else:
                             del kb.y_prime_individuals[str(y_prime)]
+                #  unblock X
                 kb.unblock_individual(x_name)
+            # now, remove Xprime from the Xprime list
             del kb.x_prime_individuals[current_individual.name]
     @staticmethod

fuzzy-dl-owl2 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

fuzzy-dl-owl2 1.0.2py3-none-any.whl → 1.0.3py3-none-any.whl