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

fuzzy_dl_owl2/fuzzydl/parser/dl_parser.py

@@ -5,107 +5,107 @@ import os
 import time
 import traceback
 import typing
-from functools import partial, reduce
+from functools import reduce
 
 import pyparsing as pp
 
 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.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.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.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.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.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.inequation import Inequation
 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.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.modifier.triangular_modifier import TriangularModifier
 from fuzzy_dl_owl2.fuzzydl.query.all_instances_query import AllInstancesQuery
 from fuzzy_dl_owl2.fuzzydl.query.bnp_query import BnpQuery
-from fuzzy_dl_owl2.fuzzydl.query.defuzzify.lom_defuzzify_query import \
-    LomDefuzzifyQuery
-from fuzzy_dl_owl2.fuzzydl.query.defuzzify.mom_defuzzify_query import \
-    MomDefuzzifyQuery
-from fuzzy_dl_owl2.fuzzydl.query.defuzzify.som_defuzzify_query import \
-    SomDefuzzifyQuery
-from fuzzy_dl_owl2.fuzzydl.query.kb_satisfiable_query import \
-    KbSatisfiableQuery
-from fuzzy_dl_owl2.fuzzydl.query.max.max_instance_query import \
-    MaxInstanceQuery
+from fuzzy_dl_owl2.fuzzydl.query.defuzzify.lom_defuzzify_query import LomDefuzzifyQuery
+from fuzzy_dl_owl2.fuzzydl.query.defuzzify.mom_defuzzify_query import MomDefuzzifyQuery
+from fuzzy_dl_owl2.fuzzydl.query.defuzzify.som_defuzzify_query import SomDefuzzifyQuery
+from fuzzy_dl_owl2.fuzzydl.query.kb_satisfiable_query import KbSatisfiableQuery
+from fuzzy_dl_owl2.fuzzydl.query.max.max_instance_query import MaxInstanceQuery
 from fuzzy_dl_owl2.fuzzydl.query.max.max_query import MaxQuery
 from fuzzy_dl_owl2.fuzzydl.query.max.max_related_query import MaxRelatedQuery
-from fuzzy_dl_owl2.fuzzydl.query.max.max_satisfiable_query import \
-    MaxSatisfiableQuery
-from fuzzy_dl_owl2.fuzzydl.query.max.max_subsumes_query import \
-    MaxSubsumesQuery
-from fuzzy_dl_owl2.fuzzydl.query.min.min_instance_query import \
-    MinInstanceQuery
+from fuzzy_dl_owl2.fuzzydl.query.max.max_satisfiable_query import MaxSatisfiableQuery
+from fuzzy_dl_owl2.fuzzydl.query.max.max_subsumes_query import MaxSubsumesQuery
+from fuzzy_dl_owl2.fuzzydl.query.min.min_instance_query import MinInstanceQuery
 from fuzzy_dl_owl2.fuzzydl.query.min.min_query import MinQuery
 from fuzzy_dl_owl2.fuzzydl.query.min.min_related_query import MinRelatedQuery
-from fuzzy_dl_owl2.fuzzydl.query.min.min_satisfiable_query import \
-    MinSatisfiableQuery
-from fuzzy_dl_owl2.fuzzydl.query.min.min_subsumes_query import \
-    MinSubsumesQuery
+from fuzzy_dl_owl2.fuzzydl.query.min.min_satisfiable_query import MinSatisfiableQuery
+from fuzzy_dl_owl2.fuzzydl.query.min.min_subsumes_query import MinSubsumesQuery
 from fuzzy_dl_owl2.fuzzydl.query.query import Query
 from fuzzy_dl_owl2.fuzzydl.util import constants, utils
 from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
-from fuzzy_dl_owl2.fuzzydl.util.constants import (ConceptType, FuzzyDLKeyword,
-                                                  FuzzyLogic, InequalityType,
-                                                  LogicOperatorType,
-                                                  RestrictionType,
-                                                  VariableType)
+from fuzzy_dl_owl2.fuzzydl.util.constants import (
+    ConceptType,
+    FuzzyDLKeyword,
+    FuzzyLogic,
+    InequalityType,
+    LogicOperatorType,
+    RestrictionType,
+    VariableType,
+)
 from fuzzy_dl_owl2.fuzzydl.util.util import Util
+from fuzzy_dl_owl2.fuzzydl.util.utils import class_debugging
 
 TODAY: datetime.datetime = datetime.datetime.today()
 LOG_DIR: str = os.path.join(
@@ -119,1116 +119,1328 @@ if not os.path.exists(LOG_DIR):
     os.makedirs(LOG_DIR)
 
 
-def _check_abstract(c: Concept) -> None:
-    if c.is_concrete():
-        Util.error(f"Error: Concept {c} should be abstract.")
-
-
-def _to_number(tokens: pp.ParseResults) -> float | int:
-    v: float = float(str(tokens.as_list()[0]))
-    return int(v) if v.is_integer() else v
-
-
-# @pp.trace_parse_action
-def _fuzzy_logic_parser(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_fuzzy_logic_parser -> {tokens}")
-    kb.set_logic(FuzzyLogic(str(tokens.as_list()[0]).lower()))
-    return tokens
-
-
-def _to_concept(kb: KnowledgeBase, c: typing.Union[str, Concept]) -> Concept:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_to_concept -> {c}")
-    return c if isinstance(c, Concept) else kb.get_concept(c)
-    # return kb.get_concept(str(c))
-
-
-def _to_top_bottom_concept(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_to_top_bottom_concept -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    if list_tokens[0] == FuzzyDLKeyword.TOP:
-        return pp.ParseResults([TruthConcept.get_top()])
-    elif list_tokens[0] == FuzzyDLKeyword.BOTTOM:
-        return pp.ParseResults([TruthConcept.get_bottom()])
-    else:
-        return pp.ParseResults([_to_concept(kb, list_tokens[0])])
-
-
-def _get_modifier(kb: KnowledgeBase, m: str) -> Modifier:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_get_modifier -> {m}")
-    if len(kb.modifiers) == 0 or m not in kb.modifiers:
-        Util.error(f"Error: {m} modifier is not defined.")
-    return kb.modifiers.get(m)
-
-
-def _parse_binary_concept(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_binary_concept -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    operator: str = list_tokens[0]
-    if operator == FuzzyDLKeyword.AND:
-        list_tokens: list[Concept] = [_to_concept(kb, t) for t in list_tokens[1:]]
-        for c in list_tokens:
-            _check_abstract(c)
-        if kb.get_logic() == FuzzyLogic.LUKASIEWICZ:
+@class_debugging()
+class DLParser(object):
+
+    kb: KnowledgeBase = None
+    queries_list: list[Query] = []
+
+    @staticmethod
+    def _check_abstract(c: Concept) -> None:
+        if c.is_concrete():
+            Util.error(f"Error: Concept {c} should be abstract.")
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _to_number(tokens: pp.ParseResults) -> float | int:
+        v: float = float(str(tokens.as_list()[0]))
+        return int(v) if v.is_integer() else v
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _fuzzy_logic_parser(tokens: pp.ParseResults) -> pp.ParseResults:
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_fuzzy_logic_parser -> {tokens}")
+        DLParser.kb.set_logic(FuzzyLogic(str(tokens.as_list()[0]).lower()))
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _to_concept(c: typing.Union[str, Concept]) -> Concept:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_to_concept -> {c}")
+        return c if isinstance(c, Concept) else DLParser.kb.get_concept(c)
+        # return DLParser.kb.get_concept(str(c))
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _to_top_bottom_concept(tokens: pp.ParseResults) -> pp.ParseResults:
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_to_top_bottom_concept -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        if list_tokens[0] == FuzzyDLKeyword.TOP:
+            return pp.ParseResults([TruthConcept.get_top()])
+        elif list_tokens[0] == FuzzyDLKeyword.BOTTOM:
+            return pp.ParseResults([TruthConcept.get_bottom()])
+        else:
+            return pp.ParseResults([DLParser._to_concept(list_tokens[0])])
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _get_modifier(m: str) -> Modifier:
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_get_modifier -> {m}")
+        if len(DLParser.kb.modifiers) == 0 or m not in DLParser.kb.modifiers:
+            Util.error(f"Error: {m} modifier is not defined.")
+        return DLParser.kb.modifiers.get(m)
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_binary_concept(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_binary_concept -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        operator: str = list_tokens[0]
+        if isinstance(operator, Concept):
+            return tokens
+        if operator == FuzzyDLKeyword.AND:
+            list_tokens: list[Concept] = [
+                DLParser._to_concept(t) for t in list_tokens[1:]
+            ]
+            for c in list_tokens:
+                DLParser._check_abstract(c)
+            if DLParser.kb.get_logic() == FuzzyLogic.LUKASIEWICZ:
+                return pp.ParseResults([OperatorConcept.lukasiewicz_and(*list_tokens)])
+            elif DLParser.kb.get_logic() == FuzzyLogic.ZADEH:
+                return pp.ParseResults([OperatorConcept.goedel_and(*list_tokens)])
+            return pp.ParseResults([OperatorConcept.and_(*list_tokens)])
+        elif operator == FuzzyDLKeyword.LUKASIEWICZ_AND:
+            list_tokens: list[Concept] = [
+                DLParser._to_concept(t) for t in list_tokens[1:]
+            ]
+            if DLParser.kb.get_logic() == FuzzyLogic.CLASSICAL:
+                Util.error(
+                    "Error: LUKASIEWICZ_AND cannot be used under classical reasoner."
+                )
+            for c in list_tokens:
+                DLParser._check_abstract(c)
             return pp.ParseResults([OperatorConcept.lukasiewicz_and(*list_tokens)])
-        elif kb.get_logic() == FuzzyLogic.ZADEH:
+        elif operator == FuzzyDLKeyword.GOEDEL_AND:
+            list_tokens: list[Concept] = [
+                DLParser._to_concept(t) for t in list_tokens[1:]
+            ]
+            if DLParser.kb.get_logic() == FuzzyLogic.CLASSICAL:
+                Util.error("Error: GOEDEL_AND cannot be used under classical reasoner.")
+            for c in list_tokens:
+                DLParser._check_abstract(c)
             return pp.ParseResults([OperatorConcept.goedel_and(*list_tokens)])
-        return pp.ParseResults([OperatorConcept.and_(*list_tokens)])
-    elif operator == FuzzyDLKeyword.LUKASIEWICZ_AND:
-        list_tokens: list[Concept] = [_to_concept(kb, t) for t in list_tokens[1:]]
-        if kb.get_logic() == FuzzyLogic.CLASSICAL:
-            Util.error(
-                "Error: LUKASIEWICZ_AND cannot be used under classical reasoner."
-            )
-        for c in list_tokens:
-            _check_abstract(c)
-        return pp.ParseResults([OperatorConcept.lukasiewicz_and(*list_tokens)])
-    elif operator == FuzzyDLKeyword.GOEDEL_AND:
-        list_tokens: list[Concept] = [_to_concept(kb, t) for t in list_tokens[1:]]
-        if kb.get_logic() == FuzzyLogic.CLASSICAL:
-            Util.error("Error: GOEDEL_AND cannot be used under classical reasoner.")
-        for c in list_tokens:
-            _check_abstract(c)
-        return pp.ParseResults([OperatorConcept.goedel_and(*list_tokens)])
-    elif operator == FuzzyDLKeyword.OR:
-        list_tokens: list[Concept] = [_to_concept(kb, t) for t in list_tokens[1:]]
-        for c in list_tokens:
-            _check_abstract(c)
-        if kb.get_logic() == FuzzyLogic.LUKASIEWICZ:
+        elif operator == FuzzyDLKeyword.OR:
+            list_tokens: list[Concept] = [
+                DLParser._to_concept(t) for t in list_tokens[1:]
+            ]
+            for c in list_tokens:
+                DLParser._check_abstract(c)
+            if DLParser.kb.get_logic() == FuzzyLogic.LUKASIEWICZ:
+                return pp.ParseResults([OperatorConcept.lukasiewicz_or(*list_tokens)])
+            elif DLParser.kb.get_logic() == FuzzyLogic.ZADEH:
+                return pp.ParseResults([OperatorConcept.goedel_or(*list_tokens)])
+            return pp.ParseResults([OperatorConcept.or_(*list_tokens)])
+        elif operator == FuzzyDLKeyword.LUKASIEWICZ_OR:
+            list_tokens: list[Concept] = [
+                DLParser._to_concept(t) for t in list_tokens[1:]
+            ]
+            if DLParser.kb.get_logic() == FuzzyLogic.CLASSICAL:
+                Util.error(
+                    "Error: LUKASIEWICZ_OR cannot be used under classical reasoner."
+                )
+            for c in list_tokens:
+                DLParser._check_abstract(c)
             return pp.ParseResults([OperatorConcept.lukasiewicz_or(*list_tokens)])
-        elif kb.get_logic() == FuzzyLogic.ZADEH:
+        elif operator == FuzzyDLKeyword.GOEDEL_OR:
+            list_tokens: list[Concept] = [
+                DLParser._to_concept(t) for t in list_tokens[1:]
+            ]
+            if DLParser.kb.get_logic() == FuzzyLogic.CLASSICAL:
+                Util.error("Error: GOEDEL_OR cannot be used under classical reasoner.")
+            for c in list_tokens:
+                DLParser._check_abstract(c)
             return pp.ParseResults([OperatorConcept.goedel_or(*list_tokens)])
-        return pp.ParseResults([OperatorConcept.or_(*list_tokens)])
-    elif operator == FuzzyDLKeyword.LUKASIEWICZ_OR:
-        list_tokens: list[Concept] = [_to_concept(kb, t) for t in list_tokens[1:]]
-        if kb.get_logic() == FuzzyLogic.CLASSICAL:
-            Util.error("Error: LUKASIEWICZ_OR cannot be used under classical reasoner.")
-        for c in list_tokens:
-            _check_abstract(c)
-        return pp.ParseResults([OperatorConcept.lukasiewicz_or(*list_tokens)])
-    elif operator == FuzzyDLKeyword.GOEDEL_OR:
-        list_tokens: list[Concept] = [_to_concept(kb, t) for t in list_tokens[1:]]
-        if kb.get_logic() == FuzzyLogic.CLASSICAL:
-            Util.error("Error: GOEDEL_OR cannot be used under classical reasoner.")
-        for c in list_tokens:
-            _check_abstract(c)
-        return pp.ParseResults([OperatorConcept.goedel_or(*list_tokens)])
-    elif operator in (
-        FuzzyDLKeyword.IMPLIES,
-        FuzzyDLKeyword.GOEDEL_IMPLIES,
-        FuzzyDLKeyword.LUKASIEWICZ_IMPLIES,
-        FuzzyDLKeyword.ZADEH_IMPLIES,
-        FuzzyDLKeyword.KLEENE_DIENES_IMPLIES,
-    ):
-        list_tokens: list[Concept] = [_to_concept(kb, t) for t in list_tokens[1:]]
-        for c in list_tokens:
-            _check_abstract(c)
-        if kb.get_logic() == FuzzyLogic.ZADEH:
+        elif operator in (
+            FuzzyDLKeyword.IMPLIES,
+            FuzzyDLKeyword.GOEDEL_IMPLIES,
+            FuzzyDLKeyword.LUKASIEWICZ_IMPLIES,
+            FuzzyDLKeyword.ZADEH_IMPLIES,
+            FuzzyDLKeyword.KLEENE_DIENES_IMPLIES,
+        ):
+            list_tokens: list[Concept] = [
+                DLParser._to_concept(t) for t in list_tokens[1:]
+            ]
+            for c in list_tokens:
+                DLParser._check_abstract(c)
+            # degree: Degree = list_tokens[2] if len(list_tokens) == 3 else DegreeNumeric.get_one()
+            # if operator == FuzzyDLKeyword.IMPLIES:
+            #     return pp.ParseResults([DLParser.kb.implies(list_tokens[0], list_tokens[1], degree)])
+            # elif operator == FuzzyDLKeyword.GOEDEL_IMPLIES:
+            #     return pp.ParseResults([DLParser.kb.goedel_implies(list_tokens[0], list_tokens[1], degree)])
+            # elif operator == FuzzyDLKeyword.LUKASIEWICZ_IMPLIES:
+            #     return pp.ParseResults([DLParser.kb.lukasiewicz_implies(list_tokens[0], list_tokens[1], degree)])
+            # elif operator == FuzzyDLKeyword.ZADEH_IMPLIES:
+            #     return pp.ParseResults([DLParser.kb.zadeh_implies(list_tokens[0], list_tokens[1])])
+            # elif operator == FuzzyDLKeyword.KLEENE_DIENES_IMPLIES:
+            #     return pp.ParseResults([DLParser.kb.kleene_dienes_implies(list_tokens[0], list_tokens[1], degree)])
+            if DLParser.kb.get_logic() == FuzzyLogic.ZADEH:
+                return pp.ParseResults(
+                    [ImpliesConcept.zadeh_implies(list_tokens[0], list_tokens[1])]
+                )
+            elif DLParser.kb.get_logic() == FuzzyLogic.CLASSICAL:
+                if operator == FuzzyDLKeyword.GOEDEL_IMPLIES:
+                    Util.error(
+                        "Error: GOEDEL_IMPLIES cannot be used under classical reasoner."
+                    )
+                elif operator == FuzzyDLKeyword.LUKASIEWICZ_IMPLIES:
+                    Util.error(
+                        "Error: LUKASIEWICZ_IMPLIES cannot be used under classical reasoner."
+                    )
+                elif operator == FuzzyDLKeyword.ZADEH_IMPLIES:
+                    Util.error(
+                        "Error: ZADEH_IMPLIES cannot be used under classical reasoner."
+                    )
+                elif operator == FuzzyDLKeyword.KLEENE_DIENES_IMPLIES:
+                    Util.error(
+                        "Error: KLEENE_DIENES_IMPLIES cannot be used under classical reasoner."
+                    )
+            if operator == FuzzyDLKeyword.GOEDEL_IMPLIES:
+                return pp.ParseResults(
+                    [ImpliesConcept.goedel_implies(list_tokens[0], list_tokens[1])]
+                )
+            elif operator == FuzzyDLKeyword.ZADEH_IMPLIES:
+                return pp.ParseResults(
+                    [ImpliesConcept.zadeh_implies(list_tokens[0], list_tokens[1])]
+                )
+            elif operator == FuzzyDLKeyword.KLEENE_DIENES_IMPLIES:
+                return pp.ParseResults(
+                    [
+                        ImpliesConcept.kleene_dienes_implies(
+                            list_tokens[0], list_tokens[1]
+                        )
+                    ]
+                )
             return pp.ParseResults(
-                [ImpliesConcept.zadeh_implies(list_tokens[0], list_tokens[1])]
+                [ImpliesConcept.lukasiewicz_implies(list_tokens[0], list_tokens[1])]
             )
-        elif kb.get_logic() == FuzzyLogic.CLASSICAL:
-            if operator == FuzzyDLKeyword.GOEDEL_IMPLIES:
-                Util.error(
-                    "Error: GOEDEL_IMPLIES cannot be used under classical reasoner."
+        elif operator == FuzzyDLKeyword.ALL:
+            role: str = list_tokens[1]
+            concept: Concept = DLParser._to_concept(list_tokens[2])
+            DLParser.kb.check_role(role, concept)
+            return pp.ParseResults([AllSomeConcept.all(role, concept)])
+        elif operator == FuzzyDLKeyword.SOME:
+            c: Concept = DLParser._to_concept(list_tokens[2])
+            role: str = list_tokens[1]
+            DLParser.kb.check_role(role, c)
+            return pp.ParseResults([AllSomeConcept.some(role, c)])
+        elif operator == FuzzyDLKeyword.HAS_VALUE:
+            ind: Individual = DLParser.kb.get_individual(list_tokens[2])
+            DLParser.kb.check_role(role, TruthConcept.get_top())
+            return pp.ParseResults([HasValueConcept.has_value(role, ind)])
+        elif operator in (
+            FuzzyDLKeyword.TIGHT_UPPER_APPROXIMATION,
+            FuzzyDLKeyword.TIGHT_LOWER_APPROXIMATION,
+            FuzzyDLKeyword.UPPER_APPROXIMATION,
+            FuzzyDLKeyword.LOWER_APPROXIMATION,
+            FuzzyDLKeyword.LOOSE_UPPER_APPROXIMATION,
+            FuzzyDLKeyword.LOOSE_LOWER_APPROXIMATION,
+        ):
+            role: str = list_tokens[1]
+            concept: Concept = DLParser._to_concept(list_tokens[2])
+            if role not in DLParser.kb.similarity_relations:
+                Util.error(f"Error: Similarity relation {role} has not been defined.")
+
+            if operator == FuzzyDLKeyword.TIGHT_UPPER_APPROXIMATION:
+                return pp.ParseResults(
+                    [
+                        ApproximationConcept.tight_upper_approx(
+                            role, concept
+                        ).to_all_some_concept()
+                    ]
                 )
-            elif operator == FuzzyDLKeyword.LUKASIEWICZ_IMPLIES:
-                Util.error(
-                    "Error: LUKASIEWICZ_IMPLIES cannot be used under classical reasoner."
+            elif operator == FuzzyDLKeyword.TIGHT_LOWER_APPROXIMATION:
+                return pp.ParseResults(
+                    [
+                        ApproximationConcept.tight_lower_approx(
+                            role, concept
+                        ).to_all_some_concept()
+                    ]
                 )
-            elif operator == FuzzyDLKeyword.ZADEH_IMPLIES:
+            elif operator == FuzzyDLKeyword.UPPER_APPROXIMATION:
+                return pp.ParseResults(
+                    [
+                        ApproximationConcept.upper_approx(
+                            role, concept
+                        ).to_all_some_concept()
+                    ]
+                )
+            elif operator == FuzzyDLKeyword.LOWER_APPROXIMATION:
+                return pp.ParseResults(
+                    [
+                        ApproximationConcept.lower_approx(
+                            role, concept
+                        ).to_all_some_concept()
+                    ]
+                )
+            elif operator == FuzzyDLKeyword.LOOSE_UPPER_APPROXIMATION:
+                return pp.ParseResults(
+                    [
+                        ApproximationConcept.loose_upper_approx(
+                            role, concept
+                        ).to_all_some_concept()
+                    ]
+                )
+            elif operator == FuzzyDLKeyword.LOOSE_LOWER_APPROXIMATION:
+                return pp.ParseResults(
+                    [
+                        ApproximationConcept.loose_lower_approx(
+                            role, concept
+                        ).to_all_some_concept()
+                    ]
+                )
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_unary_concept(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_unary_concept -> {tokens}")
+        list_tokens: list[str] = tokens.as_list()
+        operator: str = list_tokens[0]
+        if operator == FuzzyDLKeyword.NOT:
+            concept: Concept = DLParser._to_concept(list_tokens[1])
+            return pp.ParseResults([-concept])
+        elif operator == FuzzyDLKeyword.SELF:
+            role: str = list_tokens[1]
+            if role in DLParser.kb.concrete_roles:
+                Util.error(f"Error: Role {role} cannot be concrete and abstract.")
+            DLParser.kb.abstract_roles.add(role)
+            return pp.ParseResults([SelfConcept.self(role)])
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_modifier_concept(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_modifier_concept -> {tokens}")
+        list_tokens: list[str] = tokens.as_list()
+        mod: Modifier = DLParser._get_modifier(list_tokens[0])
+        concept: Concept = DLParser._to_concept(list_tokens[1])
+        return pp.ParseResults([mod.modify(concept)])
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_threshold_concept(tokens: pp.ParseResults):
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_threshold_concept -> {tokens}")
+        list_tokens: list[str] = tokens.as_list()
+        operator: str = list_tokens[0]
+        concept: Concept = DLParser._to_concept(list_tokens[2])
+        DLParser._check_abstract(concept)
+        if operator == FuzzyDLKeyword.GREATER_THAN_OR_EQUAL_TO:
+            if isinstance(list_tokens[1], (int, float)):
+                return pp.ParseResults(
+                    [ThresholdConcept.pos_threshold(list_tokens[1], concept)]
+                )
+            elif isinstance(list_tokens[1], str):
+                return pp.ParseResults(
+                    [
+                        ExtThresholdConcept.extended_pos_threshold(
+                            DLParser.kb.milp.get_variable(list_tokens[1]), concept
+                        )
+                    ]
+                )
+        elif operator == FuzzyDLKeyword.LESS_THAN_OR_EQUAL_TO:
+            if isinstance(list_tokens[1], (int, float)):
+                return pp.ParseResults(
+                    [ThresholdConcept.neg_threshold(list_tokens[1], concept)]
+                )
+            elif isinstance(list_tokens[1], str):
+                return pp.ParseResults(
+                    [
+                        ExtThresholdConcept.extended_neg_threshold(
+                            DLParser.kb.milp.get_variable(list_tokens[1]), concept
+                        )
+                    ]
+                )
+        elif operator == FuzzyDLKeyword.EQUALS:
+            if isinstance(list_tokens[1], (int, float)):
+                return pp.ParseResults([ThresholdConcept.ea(list_tokens[1], concept)])
+            elif isinstance(list_tokens[1], str):
+                return pp.ParseResults(
+                    [
+                        ExtThresholdConcept.extended_neg_threshold(
+                            DLParser.kb.milp.get_variable(list_tokens[1]), concept
+                        )
+                    ]
+                )
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_weighted_concept_simple(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_weighted_concept_simple -> {tokens}")
+        list_tokens: list[str] = tokens.as_list()
+        weight: float = list_tokens[0]
+        concept: Concept = DLParser._to_concept(list_tokens[1])
+        return pp.ParseResults([WeightedConcept(weight, concept)])
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_weighted_concept(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_weighted_concept -> {tokens}")
+        list_tokens: list[str] = tokens.as_list()
+        operator: str = list_tokens[0]
+        assert all(isinstance(c, WeightedConcept) for c in list_tokens[1:])
+        weights: list[float] = list(map(lambda x: x.weight, list_tokens[1:]))
+        concepts: list[Concept] = [
+            DLParser._to_concept(w_concept.curr_concept)
+            for w_concept in list_tokens[1:]
+        ]
+        if operator == FuzzyDLKeyword.W_SUM:
+            if not (sum(weights) <= 1.0):
                 Util.error(
-                    "Error: ZADEH_IMPLIES cannot be used under classical reasoner."
+                    "Error: The sum of the weights must be lower than or equal to 1."
                 )
-            elif operator == FuzzyDLKeyword.KLEENE_DIENES_IMPLIES:
+            return pp.ParseResults([WeightedSumConcept(weights, concepts)])
+        elif operator == FuzzyDLKeyword.W_MAX:
+            if max(weights) != 1.0:
+                Util.error("Error: The maximum of the weights must be equal to 1.")
+            return pp.ParseResults([WeightedMaxConcept(weights, concepts)])
+        elif operator == FuzzyDLKeyword.W_MIN:
+            if max(weights) != 1.0:
+                Util.error("Error: The maximum of the weights must be equal to 1.")
+            return pp.ParseResults([WeightedMinConcept(weights, concepts)])
+        elif operator == FuzzyDLKeyword.W_SUM_ZERO:
+            if not (sum(weights) <= 1.0):
                 Util.error(
-                    "Error: KLEENE_DIENES_IMPLIES cannot be used under classical reasoner."
+                    "Error: The sum of the weights must be lower than or equal to 1."
                 )
-        if operator == FuzzyDLKeyword.GOEDEL_IMPLIES:
-            return pp.ParseResults(
-                [ImpliesConcept.goedel_implies(list_tokens[0], list_tokens[1])]
+            return pp.ParseResults([WeightedSumZeroConcept(weights, concepts)])
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_q_owa_concept(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_q_owa_concept -> {tokens}")
+        list_tokens: list[str] = tokens.as_list()
+        f: FuzzyConcreteConcept = DLParser.kb.concrete_concepts.get(list_tokens[0])
+        if f is None:
+            Util.error(f"Error: Fuzzy concept {f} has to be defined before being used.")
+        if not isinstance(f, (RightConcreteConcept, LeftConcreteConcept)):
+            Util.error(
+                f"Error: Fuzzy concept {f} has to be a right or a linear function."
             )
-        elif operator == FuzzyDLKeyword.ZADEH_IMPLIES:
-            return pp.ParseResults(
-                [ImpliesConcept.zadeh_implies(list_tokens[0], list_tokens[1])]
+        concepts: list[Concept] = [
+            DLParser._to_concept(concept) for concept in list_tokens[1:]
+        ]
+        return pp.ParseResults([QowaConcept(f, concepts)])
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_owa_integral_concept(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_owa_integral_concept -> {tokens}")
+        list_tokens: list[str] = tokens.as_list()
+        operator: str = list_tokens[0]
+        length: int = len(list_tokens) - 1
+        assert length % 2 == 0
+        weights: list[float] = list_tokens[1:][: length // 2]
+        concepts: list[Concept] = [
+            DLParser._to_concept(concept) for concept in list_tokens[1:][length // 2 :]
+        ]
+        if operator == FuzzyDLKeyword.OWA:
+            if sum(weights) != 1.0:
+                Util.error("Error: The sum of the weights must be equal to 1.")
+            return pp.ParseResults([OwaConcept(weights, concepts)])
+        elif operator == FuzzyDLKeyword.CHOQUET:
+            if max(weights) != 1.0:
+                Util.error("Error: The maximum of the weights must be equal to 1.")
+            return pp.ParseResults([ChoquetIntegral(weights, concepts)])
+        elif operator == FuzzyDLKeyword.SUGENO:
+            if max(weights) != 1.0:
+                Util.error("Error: The maximum of the weights must be equal to 1.")
+            return pp.ParseResults([SugenoIntegral(weights, concepts)])
+        elif operator == FuzzyDLKeyword.QUASI_SUGENO:
+            if max(weights) != 1.0:
+                Util.error("Error: The maximum of the weights must be equal to 1.")
+            return pp.ParseResults([QsugenoIntegral(weights, concepts)])
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_modifier(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_modifier -> {tokens}")
+
+        list_tokens: list[str] = tokens.as_list()
+        if list_tokens[1] == FuzzyDLKeyword.LINEAR_MODIFIER:
+            DLParser.kb.add_modifier(
+                list_tokens[0], LinearModifier(list_tokens[0], list_tokens[2])
             )
-        elif operator == FuzzyDLKeyword.KLEENE_DIENES_IMPLIES:
-            return pp.ParseResults(
-                [ImpliesConcept.kleene_dienes_implies(list_tokens[0], list_tokens[1])]
+        elif list_tokens[1] == FuzzyDLKeyword.TRIANGULAR_MODIFIER:
+            DLParser.kb.add_modifier(
+                list_tokens[0],
+                TriangularModifier(
+                    list_tokens[0], list_tokens[2], list_tokens[3], list_tokens[4]
+                ),
             )
-        return pp.ParseResults(
-            [ImpliesConcept.lukasiewicz_implies(list_tokens[0], list_tokens[1])]
-        )
-    elif operator == FuzzyDLKeyword.ALL:
-        role: str = list_tokens[1]
-        concept: Concept = _to_concept(kb, list_tokens[2])
-        kb.check_role(role, concept)
-        return pp.ParseResults([AllSomeConcept.all(role, concept)])
-    elif operator == FuzzyDLKeyword.SOME:
-        c: Concept = _to_concept(kb, list_tokens[2])
-        role: str = list_tokens[1]
-        kb.check_role(role, c)
-        return pp.ParseResults([AllSomeConcept.some(role, c)])
-    elif operator == FuzzyDLKeyword.HAS_VALUE:
-        ind: Individual = kb.get_individual(list_tokens[2])
-        kb.check_role(role, TruthConcept.get_top())
-        return pp.ParseResults([HasValueConcept.has_value(role, ind)])
-    elif operator in (
-        FuzzyDLKeyword.TIGHT_UPPER_APPROXIMATION,
-        FuzzyDLKeyword.TIGHT_LOWER_APPROXIMATION,
-        FuzzyDLKeyword.UPPER_APPROXIMATION,
-        FuzzyDLKeyword.LOWER_APPROXIMATION,
-        FuzzyDLKeyword.LOOSE_UPPER_APPROXIMATION,
-        FuzzyDLKeyword.LOOSE_LOWER_APPROXIMATION,
-    ):
-        role: str = list_tokens[1]
-        concept: Concept = _to_concept(kb, list_tokens[2])
-        if role not in kb.similarity_relations:
-            Util.error(f"Error: Similarity relation {role} has not been defined.")
-        if operator == FuzzyDLKeyword.TIGHT_UPPER_APPROXIMATION:
-            return pp.ParseResults(
-                [ApproximationConcept.tight_upper_approx(role, concept)]
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_truth_constants(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_truth_constants -> {tokens}")
+        list_tokens: list[str] = tokens.as_list()
+        DLParser.kb.set_truth_constants(list_tokens[0], list_tokens[1])
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_fuzzy_concept(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_fuzzy_concept -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        if DLParser.kb.concrete_concepts.get(list_tokens[0]) is not None:
+            Util.error(
+                f"Error: Fuzzy concept {list_tokens[0]} has to be defined before being used."
             )
-        elif operator == FuzzyDLKeyword.TIGHT_LOWER_APPROXIMATION:
-            return pp.ParseResults(
-                [ApproximationConcept.tight_lower_approx(role, concept)]
+        if (
+            list_tokens[1] != FuzzyDLKeyword.CRISP
+            and DLParser.kb.get_logic() == FuzzyLogic.CLASSICAL
+        ):
+            Util.error(
+                f"Error: Fuzzy concept {list_tokens[0]} cannot be used with the classical reasoner."
             )
-        elif operator == FuzzyDLKeyword.UPPER_APPROXIMATION:
-            return pp.ParseResults([ApproximationConcept.upper_approx(role, concept)])
-        elif operator == FuzzyDLKeyword.LOWER_APPROXIMATION:
-            return pp.ParseResults([ApproximationConcept.lower_approx(role, concept)])
-        elif operator == FuzzyDLKeyword.LOOSE_UPPER_APPROXIMATION:
-            return pp.ParseResults(
-                [ApproximationConcept.loose_upper_approx(role, concept)]
+        if list_tokens[1] == FuzzyDLKeyword.CRISP:
+            DLParser.kb.add_concept(
+                list_tokens[0],
+                CrispConcreteConcept(
+                    list_tokens[0],
+                    list_tokens[2],
+                    list_tokens[3],
+                    list_tokens[4],
+                    list_tokens[5],
+                ),
             )
-        elif operator == FuzzyDLKeyword.LOOSE_LOWER_APPROXIMATION:
-            return pp.ParseResults(
-                [ApproximationConcept.loose_lower_approx(role, concept)]
+        elif list_tokens[1] == FuzzyDLKeyword.LEFT_SHOULDER:
+            DLParser.kb.add_concept(
+                list_tokens[0],
+                LeftConcreteConcept(
+                    list_tokens[0],
+                    list_tokens[2],
+                    list_tokens[3],
+                    list_tokens[4],
+                    list_tokens[5],
+                ),
             )
-    return tokens
+            DLParser.kb.concrete_fuzzy_concepts = True
+        elif list_tokens[1] == FuzzyDLKeyword.RIGHT_SHOULDER:
+            DLParser.kb.add_concept(
+                list_tokens[0],
+                RightConcreteConcept(
+                    list_tokens[0],
+                    list_tokens[2],
+                    list_tokens[3],
+                    list_tokens[4],
+                    list_tokens[5],
+                ),
+            )
+            DLParser.kb.concrete_fuzzy_concepts = True
+        elif list_tokens[1] == FuzzyDLKeyword.TRIANGULAR:
+            DLParser.kb.add_concept(
+                list_tokens[0],
+                TriangularConcreteConcept(
+                    list_tokens[0],
+                    list_tokens[2],
+                    list_tokens[3],
+                    list_tokens[4],
+                    list_tokens[5],
+                    list_tokens[6],
+                ),
+            )
+            DLParser.kb.concrete_fuzzy_concepts = True
+        elif list_tokens[1] == FuzzyDLKeyword.TRAPEZOIDAL:
+            DLParser.kb.add_concept(
+                list_tokens[0],
+                TrapezoidalConcreteConcept(
+                    list_tokens[0],
+                    list_tokens[2],
+                    list_tokens[3],
+                    list_tokens[4],
+                    list_tokens[5],
+                    list_tokens[6],
+                    list_tokens[7],
+                ),
+            )
+            DLParser.kb.concrete_fuzzy_concepts = True
+        elif list_tokens[1] == FuzzyDLKeyword.LINEAR:
+            DLParser.kb.add_concept(
+                list_tokens[0],
+                LinearConcreteConcept(
+                    list_tokens[0],
+                    list_tokens[2],
+                    list_tokens[3],
+                    list_tokens[4],
+                    list_tokens[5],
+                ),
+            )
+            DLParser.kb.concrete_fuzzy_concepts = True
+        elif list_tokens[1] == FuzzyDLKeyword.MODIFIED:
+            mod: Modifier = DLParser._get_modifier(list_tokens[2])
+            if DLParser.kb.concrete_concepts.get(list_tokens[3]) is None:
+                Util.error(
+                    f"Error: Fuzzy concept {list_tokens[3]} has to be defined before being used."
+                )
+            DLParser.kb.add_concept(
+                list_tokens[0],
+                ModifiedConcreteConcept(
+                    list_tokens[0],
+                    mod,
+                    DLParser.kb.concrete_concepts.get(list_tokens[3]),
+                ),
+            )
+            DLParser.kb.concrete_fuzzy_concepts = True
+        return tokens
 
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_fuzzy_number_range(tokens: pp.ParseResults) -> pp.ParseResults:
 
-def _parse_unary_concept(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_unary_concept -> {tokens}")
-    list_tokens: list[str] = tokens.as_list()
-    operator: str = list_tokens[0]
-    if operator == FuzzyDLKeyword.NOT:
-        concept: Concept = _to_concept(kb, list_tokens[1])
-        return pp.ParseResults([-concept])
-    elif operator == FuzzyDLKeyword.SELF:
-        role: str = list_tokens[1]
-        if role in kb.concrete_roles:
-            Util.error(f"Error: Role {role} cannot be concrete and abstract.")
-        kb.abstract_roles.add(role)
-        return pp.ParseResults([SelfConcept.self(role)])
-    return tokens
-
-
-def _parse_modifier_concept(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_modifier_concept -> {tokens}")
-    list_tokens: list[str] = tokens.as_list()
-    mod: Modifier = _get_modifier(kb, list_tokens[0])
-    concept: Concept = _to_concept(kb, list_tokens[1])
-    return pp.ParseResults([mod.modify(concept)])
-
-
-def _parse_threshold_concept(kb: KnowledgeBase, tokens: pp.ParseResults):
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_threshold_concept -> {tokens}")
-    list_tokens: list[str] = tokens.as_list()
-    operator: str = list_tokens[0]
-    concept: Concept = _to_concept(kb, list_tokens[2])
-    _check_abstract(concept)
-    if operator == FuzzyDLKeyword.GREATER_THAN_OR_EQUAL_TO:
-        if isinstance(list_tokens[1], (int, float)):
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_fuzzy_number_range -> {tokens}")
+        tokens = tokens.as_list()
+        TriangularFuzzyNumber.set_range(tokens[0], tokens[1])
+        return pp.ParseResults(tokens)
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _create_fuzzy_number(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_create_fuzzy_number -> {tokens}")
+        tokens = tokens.as_list()
+        if len(tokens) == 1:
+            if isinstance(tokens[0], (int, float)):
+                return pp.ParseResults(
+                    [TriangularFuzzyNumber(tokens[0], tokens[0], tokens[0])]
+                )
+            elif tokens[0] == str:
+                if tokens[0] not in DLParser.kb.fuzzy_numbers:
+                    Util.error(
+                        f"Error: Fuzzy number {tokens[0]} has to be defined before being used."
+                    )
+                return pp.ParseResults([DLParser.kb.fuzzy_numbers.get(tokens[0])])
+        elif all(isinstance(t, (int, float)) for t in tokens):
             return pp.ParseResults(
-                [ThresholdConcept.pos_threshold(list_tokens[1], concept)]
+                [TriangularFuzzyNumber(tokens[0], tokens[1], tokens[2])]
             )
-        elif isinstance(list_tokens[1], str):
-            return pp.ParseResults(
-                [
-                    ExtThresholdConcept.extended_pos_threshold(
-                        kb.milp.get_variable(list_tokens[1]), concept
-                    )
-                ]
+        return pp.ParseResults(tokens)
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _set_fuzzy_number(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_set_fuzzy_number -> {tokens}")
+        tokens = tokens.as_list()
+        if tokens[0] in DLParser.kb.fuzzy_numbers:
+            Util.error(f"Error: Fuzzy number {tokens[0]} has already been defined.")
+        for i in range(2, len(tokens)):
+            if isinstance(tokens[i], str):
+                tokens[i] = DLParser.kb.fuzzy_numbers.get(tokens[i])
+        if isinstance(tokens[1], TriangularFuzzyNumber):
+            DLParser.kb.add_fuzzy_number(tokens[0], tokens[1])
+            DLParser.kb.concrete_fuzzy_concepts = True
+            return pp.ParseResults([tokens[1]])
+        elif tokens[1] in (FuzzyDLKeyword.FEATURE_SUM, FuzzyDLKeyword.FEATURE_MUL):
+            ts: TriangularFuzzyNumber = [
+                typing.cast(TriangularFuzzyNumber, t) for t in tokens[2:]
+            ]
+            result: TriangularFuzzyNumber = reduce(
+                (
+                    TriangularFuzzyNumber.add
+                    if tokens[1] == FuzzyDLKeyword.FEATURE_SUM
+                    else TriangularFuzzyNumber.times
+                ),
+                ts,
             )
-    elif operator == FuzzyDLKeyword.LESS_THAN_OR_EQUAL_TO:
-        if isinstance(list_tokens[1], (int, float)):
-            return pp.ParseResults(
-                [ThresholdConcept.neg_threshold(list_tokens[1], concept)]
+            DLParser.kb.add_fuzzy_number(
+                tokens[0],
+                result,
             )
-        elif isinstance(list_tokens[1], str):
-            return pp.ParseResults(
-                [
-                    ExtThresholdConcept.extended_neg_threshold(
-                        kb.milp.get_variable(list_tokens[1]), concept
-                    )
-                ]
+            DLParser.kb.concrete_fuzzy_concepts = True
+            return pp.ParseResults([result])
+        elif tokens[1] in (FuzzyDLKeyword.FEATURE_SUB, FuzzyDLKeyword.FEATURE_DIV):
+            t1: TriangularFuzzyNumber = typing.cast(TriangularFuzzyNumber, tokens[2])
+            t2: TriangularFuzzyNumber = typing.cast(TriangularFuzzyNumber, tokens[3])
+            result: TriangularFuzzyNumber = (
+                t1 - t2 if tokens[1] == FuzzyDLKeyword.FEATURE_SUB else t1 / t2
             )
-    elif operator == FuzzyDLKeyword.EQUALS:
-        if isinstance(list_tokens[1], (int, float)):
-            return pp.ParseResults([ThresholdConcept.ea(list_tokens[1], concept)])
-        elif isinstance(list_tokens[1], str):
-            return pp.ParseResults(
-                [
-                    ExtThresholdConcept.extended_neg_threshold(
-                        kb.milp.get_variable(list_tokens[1]), concept
-                    )
-                ]
+            DLParser.kb.add_fuzzy_number(
+                tokens[0],
+                result,
             )
-    return tokens
-
-
-def _parse_weighted_concept_simple(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_weighted_concept_simple -> {tokens}")
-    list_tokens: list[str] = tokens.as_list()
-    weight: float = list_tokens[0]
-    concept: Concept = _to_concept(kb, list_tokens[1])
-    return pp.ParseResults([WeightedConcept(weight, concept)])
-
-
-def _parse_weighted_concept(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_weighted_concept -> {tokens}")
-    list_tokens: list[str] = tokens.as_list()
-    operator: str = list_tokens[0]
-    assert all(isinstance(c, WeightedConcept) for c in list_tokens[1:])
-    weights: list[float] = list(map(lambda x: x.weight, list_tokens[1:]))
-    if sum(weights) != 1.0:
-        Util.error("Error: The sum of the weights must be equal to 1.")
-    concepts: list[Concept] = [
-        _to_concept(kb, w_concept.curr_concept) for w_concept in list_tokens[1:]
-    ]
-    if operator == FuzzyDLKeyword.W_SUM:
-        return pp.ParseResults([WeightedSumConcept(weights, concepts)])
-    elif operator == FuzzyDLKeyword.W_MAX:
-        return pp.ParseResults([WeightedMaxConcept(weights, concepts)])
-    elif operator == FuzzyDLKeyword.W_MIN:
-        return pp.ParseResults([WeightedMinConcept(weights, concepts)])
-    elif operator == FuzzyDLKeyword.W_SUM_ZERO:
-        return pp.ParseResults([WeightedSumZeroConcept(weights, concepts)])
-    return tokens
-
-
-def _parse_q_owa_concept(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_q_owa_concept -> {tokens}")
-    list_tokens: list[str] = tokens.as_list()
-    f: FuzzyConcreteConcept = kb.concrete_concepts.get(list_tokens[0])
-    if f is None:
-        Util.error(f"Error: Fuzzy concept {f} has to be defined before being used.")
-    if not isinstance(f, (RightConcreteConcept, LeftConcreteConcept)):
-        Util.error(f"Error: Fuzzy concept {f} has to be a right or a linear function.")
-    concepts: list[Concept] = [_to_concept(kb, concept) for concept in list_tokens[1:]]
-    return pp.ParseResults([QowaConcept(f, concepts)])
-
-
-def _parse_owa_integral_concept(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_owa_integral_concept -> {tokens}")
-    list_tokens: list[str] = tokens.as_list()
-    operator: str = list_tokens[0]
-    length: int = len(list_tokens) - 1
-    assert length % 2 == 0
-    weights: list[float] = list_tokens[1:][: length // 2]
-    concepts: list[Concept] = [
-        _to_concept(kb, concept) for concept in list_tokens[1:][length // 2 :]
-    ]
-    if operator == FuzzyDLKeyword.OWA:
-        return pp.ParseResults([OwaConcept(weights, concepts)])
-    elif operator == FuzzyDLKeyword.CHOQUET:
-        return pp.ParseResults([ChoquetIntegral(weights, concepts)])
-    elif operator == FuzzyDLKeyword.SUGENO:
-        return pp.ParseResults([SugenoIntegral(weights, concepts)])
-    elif operator == FuzzyDLKeyword.QUASI_SUGENO:
-        return pp.ParseResults([QsugenoIntegral(weights, concepts)])
-    return tokens
-
-
-def _parse_modifier(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_modifier -> {tokens}")
-
-    list_tokens: list[str] = tokens.as_list()
-    if list_tokens[1] == FuzzyDLKeyword.LINEAR_MODIFIER:
-        kb.add_modifier(list_tokens[0], LinearModifier(list_tokens[0], list_tokens[2]))
-    elif list_tokens[1] == FuzzyDLKeyword.TRIANGULAR_MODIFIER:
-        kb.add_modifier(
-            list_tokens[0],
-            TriangularModifier(
-                list_tokens[0], list_tokens[2], list_tokens[3], list_tokens[4]
-            ),
-        )
-    return tokens
-
-
-def _parse_truth_constants(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_truth_constants -> {tokens}")
-    list_tokens: list[str] = tokens.as_list()
-    kb.set_truth_constants(list_tokens[0], list_tokens[1])
-    return tokens
-
-
-def _parse_fuzzy_concept(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_fuzzy_concept -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    if kb.concrete_concepts.get(list_tokens[0]) is not None:
-        Util.error(
-            f"Error: Fuzzy concept {list_tokens[0]} has to be defined before being used."
-        )
-    if (
-        list_tokens[1] != FuzzyDLKeyword.CRISP
-        and kb.get_logic() == FuzzyLogic.CLASSICAL
-    ):
-        Util.error(
-            f"Error: Fuzzy concept {list_tokens[0]} cannot be used with the classical reasoner."
-        )
-    if list_tokens[1] == FuzzyDLKeyword.CRISP:
-        kb.add_concept(
-            list_tokens[0],
-            CrispConcreteConcept(
-                list_tokens[0],
-                list_tokens[2],
-                list_tokens[3],
-                list_tokens[4],
-                list_tokens[5],
-            ),
-        )
-    elif list_tokens[1] == FuzzyDLKeyword.LEFT_SHOULDER:
-        kb.add_concept(
-            list_tokens[0],
-            LeftConcreteConcept(
-                list_tokens[0],
-                list_tokens[2],
-                list_tokens[3],
-                list_tokens[4],
-                list_tokens[5],
-            ),
-        )
-        kb.concrete_fuzzy_concepts = True
-    elif list_tokens[1] == FuzzyDLKeyword.RIGHT_SHOULDER:
-        kb.add_concept(
-            list_tokens[0],
-            RightConcreteConcept(
-                list_tokens[0],
-                list_tokens[2],
-                list_tokens[3],
-                list_tokens[4],
-                list_tokens[5],
-            ),
-        )
-        kb.concrete_fuzzy_concepts = True
-    elif list_tokens[1] == FuzzyDLKeyword.TRIANGULAR:
-        kb.add_concept(
-            list_tokens[0],
-            TriangularConcreteConcept(
-                list_tokens[0],
-                list_tokens[2],
-                list_tokens[3],
-                list_tokens[4],
-                list_tokens[5],
-                list_tokens[6],
-            ),
-        )
-        kb.concrete_fuzzy_concepts = True
-    elif list_tokens[1] == FuzzyDLKeyword.TRAPEZOIDAL:
-        kb.add_concept(
-            list_tokens[0],
-            TrapezoidalConcreteConcept(
-                list_tokens[0],
-                list_tokens[2],
-                list_tokens[3],
-                list_tokens[4],
-                list_tokens[5],
-                list_tokens[6],
-                list_tokens[7],
-            ),
-        )
-        kb.concrete_fuzzy_concepts = True
-    elif list_tokens[1] == FuzzyDLKeyword.LINEAR:
-        kb.add_concept(
-            list_tokens[0],
-            LinearConcreteConcept(
-                list_tokens[0],
-                list_tokens[2],
-                list_tokens[3],
-                list_tokens[4],
-                list_tokens[5],
-            ),
-        )
-        kb.concrete_fuzzy_concepts = True
-    elif list_tokens[1] == FuzzyDLKeyword.MODIFIED:
-        mod: Modifier = _get_modifier(kb, list_tokens[2])
-        if kb.concrete_concepts.get(list_tokens[3]) is None:
-            Util.error(
-                f"Error: Fuzzy concept {list_tokens[3]} has to be defined before being used."
+            DLParser.kb.concrete_fuzzy_concepts = True
+            return pp.ParseResults([result])
+        return pp.ParseResults(tokens)
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_feature(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_feature -> {tokens}")
+        tokens = tokens.as_list()
+        role: str = tokens[1]
+        if tokens[2] == FuzzyDLKeyword.INTEGER:
+            DLParser.kb.define_integer_concrete_feature(
+                role, int(tokens[3]), int(tokens[4])
             )
-        kb.add_concept(
-            list_tokens[0],
-            ModifiedConcreteConcept(
-                list_tokens[0],
-                mod,
-                kb.concrete_concepts.get(list_tokens[3]),
-            ),
-        )
-        kb.concrete_fuzzy_concepts = True
-    return tokens
-
-
-def _parse_fuzzy_number_range(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_fuzzy_number_range -> {tokens}")
-    tokens = tokens.as_list()
-    TriangularFuzzyNumber.set_range(tokens[0], tokens[1])
-    return pp.ParseResults(tokens)
-
-
-def _create_fuzzy_number(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_create_fuzzy_number -> {tokens}")
-    tokens = tokens.as_list()
-    if len(tokens) == 1:
-        if isinstance(tokens[0], (int, float)):
+        elif tokens[2] == FuzzyDLKeyword.REAL:
+            DLParser.kb.define_real_concrete_feature(
+                role, float(tokens[3]), float(tokens[4])
+            )
+        elif tokens[2] == FuzzyDLKeyword.BOOLEAN:
+            DLParser.kb.define_boolean_concrete_feature(role)
+        elif tokens[2] == FuzzyDLKeyword.STRING:
+            DLParser.kb.define_string_concrete_feature(role)
+        return pp.ParseResults(tokens)
+
+    def _parse_restrictions(tokens: pp.ParseResults) -> typing.Any:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_restrictions -> {tokens}")
+        tokens = tokens.as_list()
+        if isinstance(tokens[0], (list, tuple)):
+            tokens = tokens[0]
+        if len(tokens) == 1:
+            if isinstance(tokens[0], str) or isinstance(tokens[0], constants.NUMBER):
+                return pp.ParseResults([FeatureFunction(tokens[0])])
+        elif len(tokens) == 2 and isinstance(tokens[0], (int, float)):
             return pp.ParseResults(
-                [TriangularFuzzyNumber(tokens[0], tokens[0], tokens[0])]
+                [FeatureFunction(tokens[0], FeatureFunction(tokens[1]))]
             )
-        elif tokens[0] == str:
-            if tokens[0] not in kb.fuzzy_numbers:
-                Util.error(
-                    f"Error: Fuzzy number {tokens[0]} has to be defined before being used."
+        elif len(tokens) >= 3:
+            if FuzzyDLKeyword.MUL.get_value() in tokens:
+                return pp.ParseResults(
+                    [FeatureFunction(tokens[0], FeatureFunction(tokens[2]))]
                 )
-            return pp.ParseResults([kb.fuzzy_numbers.get(tokens[0])])
-    elif all(isinstance(t, (int, float)) for t in tokens):
-        return pp.ParseResults([TriangularFuzzyNumber(tokens[0], tokens[1], tokens[2])])
-    return pp.ParseResults(tokens)
-
-
-def _set_fuzzy_number(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_set_fuzzy_number -> {tokens}")
-    tokens = tokens.as_list()
-    if tokens[0] in kb.fuzzy_numbers:
-        Util.error(f"Error: Fuzzy number {tokens[0]} has already been defined.")
-    if isinstance(tokens[1], TriangularFuzzyNumber):
-        kb.add_fuzzy_number(tokens[0], tokens[1])
-        kb.concrete_fuzzy_concepts = True
-        return pp.ParseResults([tokens[1]])
-    elif tokens[1] in (FuzzyDLKeyword.FEATURE_SUM, FuzzyDLKeyword.FEATURE_MUL):
-        ts: TriangularFuzzyNumber = [
-            typing.cast(TriangularFuzzyNumber, t) for t in tokens[2:]
-        ]
-        result: TriangularFuzzyNumber = reduce(
-            (
-                TriangularFuzzyNumber.add
-                if tokens[1] == FuzzyDLKeyword.FEATURE_SUM
-                else TriangularFuzzyNumber.times
-            ),
-            ts,
-        )
-        kb.add_fuzzy_number(
-            tokens[0],
-            result,
-        )
-        kb.concrete_fuzzy_concepts = True
-        return pp.ParseResults([result])
-    elif tokens[1] in (FuzzyDLKeyword.FEATURE_SUB, FuzzyDLKeyword.FEATURE_DIV):
-        t1: TriangularFuzzyNumber = typing.cast(TriangularFuzzyNumber, tokens[2])
-        t2: TriangularFuzzyNumber = typing.cast(TriangularFuzzyNumber, tokens[3])
-        result: TriangularFuzzyNumber = (
-            t1.minus(t2)
-            if tokens[1] == FuzzyDLKeyword.FEATURE_SUB
-            else t1.divided_by(t2)
-        )
-        kb.add_fuzzy_number(
-            tokens[0],
-            result,
-        )
-        kb.concrete_fuzzy_concepts = True
-        return pp.ParseResults([result])
-    return pp.ParseResults(tokens)
-
-
-def _parse_feature(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_feature -> {tokens}")
-    tokens = tokens.as_list()
-    role: str = tokens[1]
-    if tokens[2] == FuzzyDLKeyword.INTEGER:
-        kb.define_integer_concrete_feature(role, int(tokens[3]), int(tokens[4]))
-    elif tokens[2] == FuzzyDLKeyword.REAL:
-        kb.define_real_concrete_feature(role, float(tokens[3]), float(tokens[4]))
-    elif tokens[2] == FuzzyDLKeyword.BOOLEAN:
-        kb.define_boolean_concrete_feature(role)
-    elif tokens[2] == FuzzyDLKeyword.STRING:
-        kb.define_string_concrete_feature(role)
-    return pp.ParseResults(tokens)
-
-
-def _parse_restrictions(kb: KnowledgeBase, tokens: pp.ParseResults) -> typing.Any:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_restrictions -> {tokens}")
-    tokens = tokens.as_list()
-    if len(tokens) == 1:
-        if isinstance(tokens[0], (str, int, float)):
-            return FeatureFunction(tokens[0])
-    elif len(tokens) == 2 and isinstance(tokens[0], (int, float)):
-        return FeatureFunction(tokens[0], pp.ParseResults([tokens[1]]))
-    elif len(tokens) == 3:
-        if isinstance(tokens[0], (int, float)):
-            return FeatureFunction(tokens[0], FeatureFunction(tokens[2]))
-        if isinstance(tokens[0], str):
-            if "-" in tokens:
-                return FeatureFunction(
-                    FeatureFunction(tokens[0]), FeatureFunction(tokens[2])
+            elif FuzzyDLKeyword.SUB.get_value() in tokens:
+                return pp.ParseResults(
+                    [
+                        FeatureFunction(
+                            FeatureFunction(tokens[0]), FeatureFunction(tokens[2])
+                        )
+                    ]
                 )
-            elif "+" in tokens:
-                return FeatureFunction(
-                    FeatureFunction(list(map(FeatureFunction, tokens[::2])))
+            elif FuzzyDLKeyword.SUM.get_value() in tokens:
+                return pp.ParseResults(
+                    [FeatureFunction(list(map(FeatureFunction, tokens[::2])))]
                 )
-    return pp.ParseResults(tokens)
-
-
-def _parse_datatype_restriction(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_datatype_restriction -> {tokens}")
-    list_tokens = tokens.as_list()
-    role: str = list_tokens[1]
-    if role not in kb.concrete_features:
-        Util.error(f"Error: Feature {role} has not been defined.")
-    restriction_type: RestrictionType = RestrictionType.EXACT_VALUE
-    if list_tokens[0] == FuzzyDLKeyword.LESS_THAN_OR_EQUAL_TO:
-        restriction_type = RestrictionType.AT_MOST_VALUE
-    elif list_tokens[0] == FuzzyDLKeyword.GREATER_THAN_OR_EQUAL_TO:
-        restriction_type = RestrictionType.AT_LEAST_VALUE
-    if isinstance(list_tokens[2], str):
-        if tokens[2].get_name() == "string":
-            return pp.ParseResults(
-                [kb.add_datatype_restriction(restriction_type, list_tokens[2], role)]
-            )
-        else:
-            if kb.check_fuzzy_number_concept_exists(list_tokens[2]):
+        return pp.ParseResults(tokens)
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_datatype_restriction(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_datatype_restriction -> {tokens}")
+        list_tokens = tokens.as_list()
+        role: str = list_tokens[1]
+        if role not in DLParser.kb.concrete_features:
+            Util.error(f"Error: Feature {role} has not been defined.")
+        restriction_type: RestrictionType = RestrictionType.EXACT_VALUE
+        if list_tokens[0] == FuzzyDLKeyword.LESS_THAN_OR_EQUAL_TO:
+            restriction_type = RestrictionType.AT_MOST_VALUE
+        elif list_tokens[0] == FuzzyDLKeyword.GREATER_THAN_OR_EQUAL_TO:
+            restriction_type = RestrictionType.AT_LEAST_VALUE
+        if isinstance(list_tokens[2], str):
+            # if tokens.as_dict().get("string") == tokens[2] and not DLParser.kb.check_fuzzy_number_concept_exists(list_tokens[2]):
+            #     return pp.ParseResults(
+            #         [DLParser.kb.add_datatype_restriction(restriction_type, list_tokens[2], role)]
+            #     )
+            # else:
+            if DLParser.kb.check_fuzzy_number_concept_exists(list_tokens[2]):
                 return pp.ParseResults(
                     [
-                        kb.add_datatype_restriction(
-                            restriction_type, kb.get_concept(list_tokens[2]), role
+                        DLParser.kb.add_datatype_restriction(
+                            restriction_type,
+                            DLParser.kb.get_concept(list_tokens[2]),
+                            role,
                         )
                     ]
                 )
             else:
                 v: Variable = Variable(list_tokens[2], VariableType.CONTINUOUS)
                 return pp.ParseResults(
-                    [kb.add_datatype_restriction(restriction_type, v, role)]
+                    [DLParser.kb.add_datatype_restriction(restriction_type, v, role)]
                 )
-    elif isinstance(list_tokens[2], TriangularFuzzyNumber):
-        if not TriangularFuzzyNumber.has_defined_range():
-            Util.error(
-                "Error: The range of the fuzzy numbers has to be defined before being used."
-            )
-        if list_tokens[2].is_number():
+        elif isinstance(list_tokens[2], TriangularFuzzyNumber):
+            if not TriangularFuzzyNumber.has_defined_range():
+                Util.error(
+                    "Error: The range of the fuzzy numbers has to be defined before being used."
+                )
+            if list_tokens[2].is_number():
+                return pp.ParseResults(
+                    [
+                        DLParser.kb.add_datatype_restriction(
+                            restriction_type, list_tokens[2].get_a(), role
+                        )
+                    ]
+                )
+            else:
+                return pp.ParseResults(
+                    [
+                        DLParser.kb.add_datatype_restriction(
+                            restriction_type, list_tokens[2], role
+                        )
+                    ]
+                )
+        elif isinstance(list_tokens[2], FeatureFunction):
             return pp.ParseResults(
                 [
-                    kb.add_datatype_restriction(
-                        restriction_type, list_tokens[2].get_a(), role
+                    DLParser.kb.add_datatype_restriction(
+                        restriction_type, list_tokens[2], role
                     )
                 ]
             )
-        else:
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_term(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_term -> {tokens}")
+        list_tokens: list = tokens.as_list()[0]
+        if len(list_tokens) == 1:
             return pp.ParseResults(
-                [kb.add_datatype_restriction(restriction_type, list_tokens[2], role)]
+                [Term(1.0, DLParser.kb.milp.get_variable(list_tokens[0]))]
             )
-    elif isinstance(list_tokens[2], FeatureFunction):
-        return pp.ParseResults(
-            [kb.add_datatype_restriction(restriction_type, list_tokens[2], role)]
-        )
-    return tokens
+        elif len(list_tokens) == 3:
+            return pp.ParseResults(
+                [Term(list_tokens[0], DLParser.kb.milp.get_variable(list_tokens[2]))]
+            )
+        return tokens
 
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_expression(tokens: pp.ParseResults) -> pp.ParseResults:
 
-def _parse_expression(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_expression -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    if "+" in list_tokens and "*" in list_tokens:
-        list_tokens = [t for t in list_tokens if t not in ("+", "*")]
-        constants: list[int | float] = list_tokens[::2]
-        variables: list[int | float] = list_tokens[1::2]
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_expression -> {tokens}")
+        list_tokens: list = tokens.as_list()
         expr: Expression = Expression(0)
-        for c, v in zip(constants, variables):
-            expr.add_term(Term(c, v))
-        return pp.ParseResults([expr])
-    return tokens
-
-
-def _parse_inequation(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_inequation -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    if isinstance(list_tokens[0], Expression):
-        operator: str = list_tokens[1]
-        constant: int | float = list_tokens[2]
-        expr: Expression = list_tokens[0] - constant
-        operator_type: InequalityType = (
-            InequalityType.EQUAL
-            if operator == FuzzyDLKeyword.EQUALS
-            else (
-                InequalityType.GREATER_THAN
-                if operator == FuzzyDLKeyword.GREATER_THAN_OR_EQUAL_TO
-                else InequalityType.LESS_THAN
+        if isinstance(list_tokens[0], (tuple, list)):
+            list_tokens = list_tokens[0]
+        if len(list_tokens) == 1 and isinstance(list_tokens[0], Term):
+            expr.add_term(list_tokens[0])
+            return expr
+        if "+" in list_tokens and all(
+            isinstance(term, Term) for term in list_tokens[::2]
+        ):
+            for term in list_tokens[::2]:
+                expr.add_term(term)
+            return pp.ParseResults([expr])
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_inequation(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_inequation -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        if isinstance(list_tokens[0], Expression):
+            operator: str = list_tokens[1]
+            constant: int | float = list_tokens[2]
+            expr: Expression = list_tokens[0] - constant
+            operator_type: InequalityType = (
+                InequalityType.EQUAL
+                if operator == FuzzyDLKeyword.EQUALS
+                else (
+                    InequalityType.GREATER_THAN
+                    if operator == FuzzyDLKeyword.GREATER_THAN_OR_EQUAL_TO
+                    else InequalityType.LESS_THAN
+                )
             )
-        )
-        kb.milp.add_new_constraint(expr, operator_type)
-    return tokens
-
-
-def _parse_constraints(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_constraints -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    if list_tokens[0] == FuzzyDLKeyword.BINARY:
-        v: Variable = kb.milp.get_variable(list_tokens[1])
-        v.set_type(VariableType.BINARY)
-    elif list_tokens[0] == FuzzyDLKeyword.FREE:
-        v: Variable = kb.milp.get_variable(list_tokens[1])
-        v.set_type(VariableType.CONTINUOUS)
-    return tokens
-
-
-def _show_concrete_fillers(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_show_concrete_fillers -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    for role in list_tokens:
-        if role in kb.concrete_roles:
-            kb.milp.show_vars.add_concrete_filler_to_show(role)
-        else:
+            DLParser.kb.milp.add_new_constraint(expr, operator_type)
+            return pp.ParseResults([Inequation(expr, operator_type)])
+        return tokens
+
+    @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()
+        if list_tokens[0] == FuzzyDLKeyword.BINARY:
+            v: Variable = DLParser.kb.milp.get_variable(list_tokens[1])
+            v.set_type(VariableType.BINARY)
+        elif list_tokens[0] == FuzzyDLKeyword.FREE:
+            v: Variable = DLParser.kb.milp.get_variable(list_tokens[1])
+            v.set_type(VariableType.CONTINUOUS)
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _show_concrete_fillers(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_show_concrete_fillers -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        for role in list_tokens:
+            if role in DLParser.kb.concrete_roles:
+                DLParser.kb.milp.show_vars.add_concrete_filler_to_show(role)
+            else:
+                Util.error(
+                    "Error: show-concrete-fillers can only be used with concrete roles."
+                )
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _show_concrete_fillers_for(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_show_concrete_fillers_for -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        ind_name: str = list_tokens[0]
+        for role in list_tokens[1:]:
+            if role in DLParser.kb.concrete_roles:
+                DLParser.kb.milp.show_vars.add_concrete_filler_to_show(role, ind_name)
+            else:
+                Util.error(
+                    "Error: show-concrete-fillers-for can only be used with concrete roles."
+                )
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _show_concrete_instance_for(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_show_concrete_instance_for -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        ind_name: str = list_tokens[0]
+        role: str = list_tokens[1]
+        if role not in DLParser.kb.concrete_roles:
             Util.error(
-                "Error: show-concrete-fillers can only be used with concrete roles."
+                "Error: show-concrete-instance-for can only be used with concrete roles."
             )
-    return tokens
+        ar: list[FuzzyConcreteConcept] = []
+        for c_name in list_tokens[2:]:
+            concept: Concept = DLParser.kb.concrete_concepts.get(c_name)
+            if concept is None:
+                Util.error(
+                    f"Error: Concrete fuzzy concept {c_name} has not been defined."
+                )
+            if concept.type not in (ConceptType.CONCRETE, ConceptType.FUZZY_NUMBER):
+                Util.error(f"Error: {c_name} is not a concrete fuzzy concept.")
+            ar.append(typing.cast(FuzzyConcreteConcept, concept))
+        DLParser.kb.milp.show_vars.add_concrete_filler_to_show(role, ind_name, ar)
+        return tokens
 
+    @staticmethod
+    # @pp.trace_parse_action
+    def _show_abstract_fillers(tokens: pp.ParseResults) -> pp.ParseResults:
 
-def _show_concrete_fillers_for(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_show_concrete_fillers_for -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    ind_name: str = list_tokens[0]
-    for role in list_tokens[1:]:
-        if role in kb.concrete_roles:
-            kb.milp.show_vars.add_concrete_filler_to_show(role, ind_name)
-        else:
-            Util.error(
-                "Error: show-concrete-fillers-for can only be used with concrete roles."
-            )
-    return tokens
-
-
-def _show_concrete_instance_for(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_show_concrete_instance_for -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    ind_name: str = list_tokens[0]
-    role: str = list_tokens[1]
-    if role not in kb.concrete_roles:
-        Util.error(
-            "Error: show-concrete-instance-for can only be used with concrete roles."
-        )
-    ar: list[FuzzyConcreteConcept] = []
-    for c_name in list_tokens[2:]:
-        concept: Concept = kb.concrete_concepts.get(c_name)
-        if concept is None:
-            Util.error(f"Error: Concrete fuzzy concept {c_name} has not been defined.")
-        if concept.type not in (ConceptType.CONCRETE, ConceptType.FUZZY_NUMBER):
-            Util.error(f"Error: {c_name} is not a concrete fuzzy concept.")
-        ar.append(typing.cast(FuzzyConcreteConcept, concept))
-    kb.milp.show_vars.add_concrete_filler_to_show(role, ind_name, ar)
-    return tokens
-
-
-def _show_abstract_fillers(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_show_abstract_fillers -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    for role in list_tokens:
-        if role in kb.concrete_roles:
-            Util.error(
-                "Error: show-abstract-fillers can only be used with abstract roles."
-            )
-            continue
-        kb.milp.show_vars.add_abstract_filler_to_show(role)
-    return tokens
-
-
-def _show_abstract_fillers_for(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_show_abstract_fillers_for -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    ind_name: str = list_tokens[1:]
-    for role in list_tokens:
-        if role in kb.concrete_roles:
-            Util.error(
-                "Error: show-abstract-fillers-for can only be used with abstract roles."
-            )
-        kb.milp.show_vars.add_abstract_filler_to_show(role, ind_name)
-    return tokens
-
-
-def _show_concepts(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_show_concepts -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    for ind_name in list_tokens:
-        kb.milp.show_vars.add_individual_to_show(ind_name)
-    return tokens
-
-
-def _show_instances(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_show_instances -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    for concept in list_tokens:
-        concept: Concept = _to_concept(kb, concept)
-        kb.milp.show_vars.add_concept_to_show(str(concept))
-    return tokens
-
-
-def _show_variables(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_show_variables -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    for variable_name in list_tokens:
-        var: Variable = kb.milp.get_variable(variable_name)
-        kb.milp.show_vars.add_variable(var, str(var))
-    return tokens
-
-
-def _show_languages(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_show_languages -> {tokens}")
-    kb.show_language = True
-    return tokens
-
-
-def _parse_crisp_declarations(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_crisp_declarations -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    if list_tokens[0] == FuzzyDLKeyword.CRISP_CONCEPT:
-        for concept in list_tokens[1:]:
-            concept: Concept = _to_concept(kb, concept)
-            kb.set_crisp_concept(concept)
-    elif list_tokens[0] == FuzzyDLKeyword.CRISP_ROLE:
-        for role in list_tokens[1:]:
-            kb.set_crisp_role(role)
-    return tokens
-
-
-def _parse_fuzzy_similarity(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_fuzzy_similarity -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    kb.add_similarity_relation(list_tokens[0])
-    return tokens
-
-
-def _parse_fuzzy_equivalence(
-    kb: KnowledgeBase, tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_fuzzy_equivalence -> {tokens}")
-    list_tokens: list = tokens.as_list()
-    kb.add_equivalence_relation(list_tokens[0])
-    return tokens
-
-
-def _parse_degree(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_degree -> {tokens}")
-
-    list_tokens: list = tokens.as_list()
-    if isinstance(list_tokens[0], (int, float)):
-        return pp.ParseResults([DegreeNumeric.get_degree(float(list_tokens[0]))])
-    elif isinstance(list_tokens[0], Expression):
-        return pp.ParseResults([DegreeExpression.get_degree(list_tokens[0])])
-    elif isinstance(list_tokens[0], str):
-        tc: typing.Optional[float] = kb.get_truth_constants(list_tokens[0])
-        if tc is not None:
-            return pp.ParseResults([DegreeNumeric.get_degree(float(tc))])
-        else:
-            return pp.ParseResults(
-                [DegreeVariable.get_degree(kb.milp.get_variable(list_tokens[0]))]
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_show_abstract_fillers -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        for role in list_tokens:
+            if role in DLParser.kb.concrete_roles:
+                Util.error(
+                    "Error: show-abstract-fillers can only be used with abstract roles."
+                )
+                continue
+            DLParser.kb.milp.show_vars.add_abstract_filler_to_show(role)
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _show_abstract_fillers_for(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_show_abstract_fillers_for -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        ind_name: str = list_tokens[1:]
+        for role in list_tokens:
+            if role in DLParser.kb.concrete_roles:
+                Util.error(
+                    "Error: show-abstract-fillers-for can only be used with abstract roles."
+                )
+            DLParser.kb.milp.show_vars.add_abstract_filler_to_show(role, ind_name)
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _show_concepts(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_show_concepts -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        for ind_name in list_tokens:
+            DLParser.kb.milp.show_vars.add_individual_to_show(ind_name)
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _show_instances(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_show_instances -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        for concept in list_tokens:
+            concept: Concept = DLParser._to_concept(concept)
+            DLParser.kb.milp.show_vars.add_concept_to_show(str(concept))
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _show_variables(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_show_variables -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        for variable_name in list_tokens:
+            var: Variable = DLParser.kb.milp.get_variable(variable_name)
+            DLParser.kb.milp.show_vars.add_variable(var, str(var))
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _show_languages(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_show_languages -> {tokens}")
+        DLParser.kb.show_language = True
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_crisp_declarations(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_crisp_declarations -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        if list_tokens[0] == FuzzyDLKeyword.CRISP_CONCEPT:
+            for concept in list_tokens[1:]:
+                concept: Concept = DLParser._to_concept(concept)
+                DLParser.kb.set_crisp_concept(concept)
+        elif list_tokens[0] == FuzzyDLKeyword.CRISP_ROLE:
+            for role in list_tokens[1:]:
+                DLParser.kb.set_crisp_role(role)
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_fuzzy_similarity(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_fuzzy_similarity -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        DLParser.kb.add_similarity_relation(list_tokens[0])
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_fuzzy_equivalence(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_fuzzy_equivalence -> {tokens}")
+        list_tokens: list = tokens.as_list()
+        DLParser.kb.add_equivalence_relation(list_tokens[0])
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_degree(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_degree -> {tokens}")
+
+        list_tokens: list = tokens.as_list()
+        if isinstance(list_tokens[0], (int, float)):
+            return pp.ParseResults([DegreeNumeric.get_degree(float(list_tokens[0]))])
+        elif isinstance(list_tokens[0], Expression):
+            return pp.ParseResults([DegreeExpression.get_degree(list_tokens[0])])
+        elif isinstance(list_tokens[0], str):
+            tc: typing.Optional[float] = DLParser.kb.get_truth_constants(list_tokens[0])
+            if tc is not None:
+                return pp.ParseResults([DegreeNumeric.get_degree(float(tc))])
+            else:
+                return pp.ParseResults(
+                    [
+                        DegreeVariable.get_degree(
+                            DLParser.kb.milp.get_variable(list_tokens[0])
+                        )
+                    ]
+                )
+        return tokens
+
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_axioms(tokens: pp.ParseResults) -> pp.ParseResults:
+
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_axioms -> {tokens}")
+
+        list_tokens: list = tokens.as_list()[0]
+        if list_tokens[0] == FuzzyDLKeyword.INSTANCE:
+            a: Individual = DLParser.kb.get_individual(list_tokens[1])
+            c: Concept = DLParser._to_concept(list_tokens[2])
+            d: Degree = (
+                list_tokens[3]
+                if len(list_tokens) > 3
+                else DegreeNumeric.get_degree(1.0)
+            )
+            DLParser.kb.add_assertion(a, c, d)
+        elif list_tokens[0] == FuzzyDLKeyword.RELATED:
+            a: Individual = DLParser.kb.get_individual(list_tokens[1])
+            b: Individual = DLParser.kb.get_individual(list_tokens[2])
+            role: str = list_tokens[3]
+            d: Degree = (
+                list_tokens[4]
+                if len(list_tokens) > 4
+                else DegreeNumeric.get_degree(1.0)
+            )
+            if role in DLParser.kb.concrete_roles:
+                Util.error(f"Error: Role {role} cannot be concrete and abstract.")
+            DLParser.kb.add_relation(a, role, b, d)
+        elif list_tokens[0] in (
+            FuzzyDLKeyword.GOEDEL_IMPLIES,
+            FuzzyDLKeyword.LUKASIEWICZ_IMPLIES,
+            FuzzyDLKeyword.KLEENE_DIENES_IMPLIES,
+            FuzzyDLKeyword.ZADEH_IMPLIES,
+            FuzzyDLKeyword.IMPLIES,
+        ):
+            c1: Concept = DLParser._to_concept(list_tokens[1])
+            c2: Concept = DLParser._to_concept(list_tokens[2])
+            d: Degree = (
+                list_tokens[3]
+                if len(list_tokens) > 3
+                else DegreeNumeric.get_degree(1.0)
             )
-    return tokens
+            if list_tokens[0] == FuzzyDLKeyword.IMPLIES:
+                DLParser.kb.implies(c1, c2, d)
+            elif list_tokens[0] == FuzzyDLKeyword.GOEDEL_IMPLIES:
+                DLParser.kb.goedel_implies(c1, c2, d)
+            elif list_tokens[0] == FuzzyDLKeyword.LUKASIEWICZ_IMPLIES:
+                DLParser.kb.lukasiewicz_implies(c1, c2, d)
+            elif list_tokens[0] == FuzzyDLKeyword.KLEENE_DIENES_IMPLIES:
+                DLParser.kb.kleene_dienes_implies(c1, c2, d)
+            elif list_tokens[0] == FuzzyDLKeyword.ZADEH_IMPLIES:
+                DLParser.kb.zadeh_implies(c1, c2)
+        elif list_tokens[0] == FuzzyDLKeyword.ZADEH_IMPLIES:
+            c1: Concept = DLParser._to_concept(list_tokens[1])
+            c2: Concept = DLParser._to_concept(list_tokens[2])
+            DLParser.kb.zadeh_implies(c1, c2)
+        elif list_tokens[0] == FuzzyDLKeyword.DEFINE_CONCEPT:
+            name: str = list_tokens[1]
+            c: Concept = DLParser._to_concept(list_tokens[2])
+            DLParser.kb.define_concept(name, c)
+        elif list_tokens[0] == FuzzyDLKeyword.DEFINE_PRIMITIVE_CONCEPT:
+            name: str = list_tokens[1]
+            c: Concept = DLParser._to_concept(list_tokens[2])
+            DLParser.kb.define_atomic_concept(name, c, LogicOperatorType.ZADEH, 1.0)
+        elif list_tokens[0] == FuzzyDLKeyword.EQUIVALENT_CONCEPTS:
+            c1: Concept = DLParser._to_concept(list_tokens[1])
+            c2: Concept = DLParser._to_concept(list_tokens[2])
+            DLParser.kb.define_equivalent_concepts(c1, c2)
+        elif list_tokens[0] == FuzzyDLKeyword.DISJOINT_UNION:
+            concepts: list[str] = [
+                str(DLParser._to_concept(t)) for t in list_tokens[1:]
+            ]
+            DLParser.kb.add_disjoint_union_concept(concepts)
+        elif list_tokens[0] == FuzzyDLKeyword.DISJOINT:
+            concepts: list[Concept] = [DLParser._to_concept(t) for t in list_tokens[1:]]
+            DLParser.kb.add_concepts_disjoint(concepts)
+        elif list_tokens[0] in (FuzzyDLKeyword.RANGE, FuzzyDLKeyword.DOMAIN):
+            role: str = list_tokens[1]
+            concept: Concept = DLParser._to_concept(list_tokens[2])
+            if list_tokens[0] == FuzzyDLKeyword.RANGE:
+                DLParser.kb.check_role(role, concept)
+                DLParser.kb.role_range(role, concept)
+            else:
+                DLParser.kb.role_domain(role, concept)
+        elif list_tokens[0] == FuzzyDLKeyword.FUNCTIONAL:
+            role: str = list_tokens[1]
+            DLParser.kb.role_is_functional(role)
+        elif list_tokens[0] == FuzzyDLKeyword.TRANSITIVE:
+            role: str = list_tokens[1]
+            DLParser.kb.role_is_transitive(role)
+        elif list_tokens[0] == FuzzyDLKeyword.SYMMETRIC:
+            role: str = list_tokens[1]
+            DLParser.kb.role_is_symmetric(role)
+        elif list_tokens[0] == FuzzyDLKeyword.REFLEXIVE:
+            role: str = list_tokens[1]
+            DLParser.kb.role_is_reflexive(role)
+        elif list_tokens[0] == FuzzyDLKeyword.INVERSE_FUNCTIONAL:
+            role: str = list_tokens[1]
+            if role in DLParser.kb.concrete_roles:
+                Util.error(f"Error: Concrete role {role} cannot have an inverse role.")
+            DLParser.kb.role_is_inverse_functional(role)
+        elif list_tokens[0] == FuzzyDLKeyword.INVERSE:
+            role: str = list_tokens[1]
+            inv_role: str = list_tokens[2]
+            if role in DLParser.kb.concrete_roles:
+                Util.error(f"Error: Concrete role {role} cannot have an inverse role.")
+            elif inv_role in DLParser.kb.concrete_roles:
+                Util.error(
+                    f"Error: Concrete role {inv_role} cannot have an inverse role."
+                )
+            else:
+                DLParser.kb.add_inverse_roles(role, inv_role)
+        elif list_tokens[0] == FuzzyDLKeyword.IMPLIES_ROLE:
+            role_c: str = list_tokens[1]
+            role_p: str = list_tokens[2]
+            d: float = list_tokens[3] if len(list_tokens) > 3 else 1.0
+            DLParser.kb.role_implies(role_c, role_p, d)
+        return tokens
 
+    @staticmethod
+    # @pp.trace_parse_action
+    def _parse_queries(tokens: pp.ParseResults) -> pp.ParseResults:
 
-def _parse_axioms(kb: KnowledgeBase, tokens: pp.ParseResults) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_axioms -> {tokens}")
+        if ConfigReader.DEBUG_PRINT:
+            Util.debug(f"\t\t_parse_queries -> {tokens}")
 
-    list_tokens: list = tokens.as_list()[0]
-    if list_tokens[0] == FuzzyDLKeyword.INSTANCE:
-        a: Individual = kb.get_individual(list_tokens[1])
-        c: Concept = _to_concept(kb, list_tokens[2])
-        d: Degree = (
-            list_tokens[3] if len(list_tokens) > 3 else DegreeNumeric.get_degree(1.0)
-        )
-        kb.add_assertion(a, c, d)
-    elif list_tokens[0] == FuzzyDLKeyword.RELATED:
-        a: Individual = kb.get_individual(list_tokens[1])
-        b: Individual = kb.get_individual(list_tokens[2])
-        role: str = list_tokens[3]
-        d: Degree = (
-            list_tokens[4] if len(list_tokens) > 4 else DegreeNumeric.get_degree(1.0)
-        )
-        if role in kb.concrete_roles:
-            Util.error(f"Error: Role {role} cannot be concrete and abstract.")
-        kb.add_relation(a, role, b, d)
-    elif list_tokens[0] in (
-        FuzzyDLKeyword.GOEDEL_IMPLIES,
-        FuzzyDLKeyword.LUKASIEWICZ_IMPLIES,
-        FuzzyDLKeyword.KLEENE_DIENES_IMPLIES,
-        FuzzyDLKeyword.IMPLIES,
-    ):
-        c1: Concept = _to_concept(kb, list_tokens[1])
-        c2: Concept = _to_concept(kb, list_tokens[2])
-        d: Degree = (
-            list_tokens[3] if len(list_tokens) > 3 else DegreeNumeric.get_degree(1.0)
-        )
-        if list_tokens[0] == FuzzyDLKeyword.IMPLIES:
-            kb.implies(c1, c2, d)
-        elif list_tokens[0] == FuzzyDLKeyword.GOEDEL_IMPLIES:
-            kb.goedel_implies(c1, c2, d)
-        elif list_tokens[0] == FuzzyDLKeyword.LUKASIEWICZ_IMPLIES:
-            kb.lukasiewicz_implies(c1, c2, d)
-        elif list_tokens[0] == FuzzyDLKeyword.KLEENE_DIENES_IMPLIES:
-            kb.kleene_dienes_implies(c1, c2, d)
-    elif list_tokens[0] == FuzzyDLKeyword.ZADEH_IMPLIES:
-        c1: Concept = _to_concept(kb, list_tokens[1])
-        c2: Concept = _to_concept(kb, list_tokens[2])
-        kb.zadeh_implies(c1, c2)
-    elif list_tokens[0] == FuzzyDLKeyword.DEFINE_CONCEPT:
-        name: str = list_tokens[1]
-        c: Concept = _to_concept(kb, list_tokens[2])
-        kb.define_concept(name, c)
-    elif list_tokens[0] == FuzzyDLKeyword.DEFINE_PRIMITIVE_CONCEPT:
-        name: str = list_tokens[1]
-        c: Concept = _to_concept(kb, list_tokens[2])
-        kb.define_atomic_concept(name, c, LogicOperatorType.ZADEH, 1.0)
-    elif list_tokens[0] == FuzzyDLKeyword.EQUIVALENT_CONCEPTS:
-        c1: Concept = _to_concept(kb, list_tokens[1])
-        c2: Concept = _to_concept(kb, list_tokens[2])
-        kb.define_equivalent_concepts(c1, c2)
-    elif list_tokens[0] == FuzzyDLKeyword.DISJOINT_UNION:
-        concepts: list[str] = [str(_to_concept(kb, t)) for t in list_tokens[1:]]
-        kb.add_disjoint_union_concept(concepts)
-    elif list_tokens[0] == FuzzyDLKeyword.DISJOINT:
-        concepts: list[Concept] = [_to_concept(kb, t) for t in list_tokens[1:]]
-        kb.add_concepts_disjoint(concepts)
-    elif list_tokens[0] in (FuzzyDLKeyword.RANGE, FuzzyDLKeyword.DOMAIN):
-        role: str = list_tokens[1]
-        concept: Concept = _to_concept(kb, list_tokens[2])
-        if list_tokens[0] == FuzzyDLKeyword.RANGE:
-            kb.check_role(role, concept)
-            kb.role_range(role, concept)
-        else:
-            kb.role_domain(role, concept)
-    elif list_tokens[0] == FuzzyDLKeyword.FUNCTIONAL:
-        role: str = list_tokens[1]
-        kb.role_is_functional(role)
-    elif list_tokens[0] == FuzzyDLKeyword.TRANSITIVE:
-        role: str = list_tokens[1]
-        kb.role_is_transitive(role)
-    elif list_tokens[0] == FuzzyDLKeyword.SYMMETRIC:
-        role: str = list_tokens[1]
-        kb.role_is_symmetric(role)
-    elif list_tokens[0] == FuzzyDLKeyword.REFLEXIVE:
-        role: str = list_tokens[1]
-        kb.role_is_reflexive(role)
-    elif list_tokens[0] == FuzzyDLKeyword.INVERSE_FUNCTIONAL:
-        role: str = list_tokens[1]
-        if role in kb.concrete_roles:
-            Util.error(f"Error: Concrete role {role} cannot have an inverse role.")
-        kb.role_is_inverse_functional(role)
-    elif list_tokens[0] == FuzzyDLKeyword.INVERSE:
-        role: str = list_tokens[1]
-        inv_role: str = list_tokens[2]
-        if role in kb.concrete_roles:
-            Util.error(f"Error: Concrete role {role} cannot have an inverse role.")
-        elif inv_role in kb.concrete_roles:
-            Util.error(f"Error: Concrete role {inv_role} cannot have an inverse role.")
-        else:
-            kb.add_inverse_roles(role, inv_role)
-    elif list_tokens[0] == FuzzyDLKeyword.IMPLIES_ROLE:
-        role_c: str = list_tokens[1]
-        role_p: str = list_tokens[2]
-        d: float = list_tokens[3] if len(list_tokens) > 3 else 1.0
-        kb.role_implies(role_c, role_p, d)
-    return tokens
-
-
-def _parse_queries(
-    kb: KnowledgeBase, queries_list: list[Query], tokens: pp.ParseResults
-) -> pp.ParseResults:
-    if ConfigReader.DEBUG_PRINT:
-        Util.debug(f"\t\t_parse_queries -> {tokens}")
-
-    list_tokens: list[str] = tokens.as_list()[0]
-
-    if list_tokens[0] == FuzzyDLKeyword.ALL_INSTANCES_QUERY:
-        queries_list.append(AllInstancesQuery(list_tokens[1]))
-    elif list_tokens[0] == FuzzyDLKeyword.SAT_QUERY:
-        queries_list.append(KbSatisfiableQuery())
-    elif list_tokens[0] in (FuzzyDLKeyword.MIN_SAT_QUERY, FuzzyDLKeyword.MAX_SAT_QUERY):
-        _class: Query = (
-            MinSatisfiableQuery
-            if list_tokens[0] == FuzzyDLKeyword.MIN_SAT_QUERY
-            else MaxSatisfiableQuery
-        )
-        c: Concept = _to_concept(kb, list_tokens[1])
-        if len(list_tokens) > 2:
-            queries_list.append(_class(c, kb.get_individual(list_tokens[2])))
-        else:
-            queries_list.append(_class(c))
-    elif list_tokens[0] in (
-        FuzzyDLKeyword.MAX_INSTANCE_QUERY,
-        FuzzyDLKeyword.MIN_INSTANCE_QUERY,
-    ):
-        _class: Query = (
-            MaxInstanceQuery
-            if list_tokens[0] == FuzzyDLKeyword.MAX_INSTANCE_QUERY
-            else MinInstanceQuery
-        )
-        a: Individual = kb.get_individual(list_tokens[1])
-        c: Concept = _to_concept(kb, list_tokens[2])
-        queries_list.append(_class(c, a))
-    elif list_tokens[0] in (
-        FuzzyDLKeyword.MAX_SUBS_QUERY,
-        FuzzyDLKeyword.MIN_SUBS_QUERY,
-        FuzzyDLKeyword.MAX_G_SUBS_QUERY,
-        FuzzyDLKeyword.MIN_G_SUBS_QUERY,
-        FuzzyDLKeyword.MAX_L_SUBS_QUERY,
-        FuzzyDLKeyword.MIN_L_SUBS_QUERY,
-        FuzzyDLKeyword.MAX_KD_SUBS_QUERY,
-        FuzzyDLKeyword.MIN_KD_SUBS_QUERY,
-    ):
-        _class = (
-            MaxSubsumesQuery
-            if list_tokens[0].lower().startswith("max")
-            else MinSubsumesQuery
-        )
-        c1: Concept = _to_concept(kb, list_tokens[1])
-        c2: Concept = _to_concept(kb, list_tokens[2])
-        if list_tokens[0] in (
-            FuzzyDLKeyword.MAX_SUBS_QUERY,
-            FuzzyDLKeyword.MIN_SUBS_QUERY,
+        list_tokens: list[str] = tokens.as_list()[0]
+
+        if list_tokens[0] == FuzzyDLKeyword.ALL_INSTANCES_QUERY:
+            DLParser.queries_list.append(AllInstancesQuery(list_tokens[1]))
+        elif list_tokens[0] == FuzzyDLKeyword.SAT_QUERY:
+            DLParser.queries_list.append(KbSatisfiableQuery())
+        elif list_tokens[0] in (
+            FuzzyDLKeyword.MIN_SAT_QUERY,
+            FuzzyDLKeyword.MAX_SAT_QUERY,
         ):
-            if kb.get_logic() == FuzzyLogic.LUKASIEWICZ:
-                queries_list.append(_class(c1, c2, LogicOperatorType.LUKASIEWICZ))
+            _class: Query = (
+                MinSatisfiableQuery
+                if list_tokens[0] == FuzzyDLKeyword.MIN_SAT_QUERY
+                else MaxSatisfiableQuery
+            )
+            c: Concept = DLParser._to_concept(list_tokens[1])
+            if len(list_tokens) > 2:
+                DLParser.queries_list.append(
+                    _class(c, DLParser.kb.get_individual(list_tokens[2]))
+                )
             else:
-                queries_list.append(_class(c1, c2, LogicOperatorType.ZADEH))
+                DLParser.queries_list.append(_class(c))
         elif list_tokens[0] in (
-            FuzzyDLKeyword.MAX_G_SUBS_QUERY,
-            FuzzyDLKeyword.MIN_G_SUBS_QUERY,
+            FuzzyDLKeyword.MAX_INSTANCE_QUERY,
+            FuzzyDLKeyword.MIN_INSTANCE_QUERY,
         ):
-            queries_list.append(_class(c1, c2, LogicOperatorType.GOEDEL))
+            _class: Query = (
+                MaxInstanceQuery
+                if list_tokens[0] == FuzzyDLKeyword.MAX_INSTANCE_QUERY
+                else MinInstanceQuery
+            )
+            a: Individual = DLParser.kb.get_individual(list_tokens[1])
+            c: Concept = DLParser._to_concept(list_tokens[2])
+            DLParser.queries_list.append(_class(c, a))
         elif list_tokens[0] in (
+            FuzzyDLKeyword.MAX_SUBS_QUERY,
+            FuzzyDLKeyword.MIN_SUBS_QUERY,
+            FuzzyDLKeyword.MAX_G_SUBS_QUERY,
+            FuzzyDLKeyword.MIN_G_SUBS_QUERY,
             FuzzyDLKeyword.MAX_L_SUBS_QUERY,
             FuzzyDLKeyword.MIN_L_SUBS_QUERY,
-        ):
-            queries_list.append(_class(c1, c2, LogicOperatorType.LUKASIEWICZ))
-        elif list_tokens[0] in (
             FuzzyDLKeyword.MAX_KD_SUBS_QUERY,
             FuzzyDLKeyword.MIN_KD_SUBS_QUERY,
         ):
-            queries_list.append(_class(c1, c2, LogicOperatorType.KLEENE_DIENES))
-    elif list_tokens[0] in (
-        FuzzyDLKeyword.MAX_RELATED_QUERY,
-        FuzzyDLKeyword.MIN_RELATED_QUERY,
-    ):
-        a: Individual = kb.get_individual(list_tokens[1])
-        b: Individual = kb.get_individual(list_tokens[2])
-        role: str = list_tokens[3]
-        if role in kb.concrete_roles:
-            Util.error(f"Error: Role {role} cannot be concrete and abstract.")
-        kb.abstract_roles.add(role)
-        if list_tokens[0] == FuzzyDLKeyword.MAX_RELATED_QUERY:
-            queries_list.append(MaxRelatedQuery(a, b, role))
-        else:
-            queries_list.append(MinRelatedQuery(a, b, role))
-    elif list_tokens[0] == FuzzyDLKeyword.MAX_VAR_QUERY:
-        queries_list.append(MaxQuery(list_tokens[1]))
-    elif list_tokens[0] == FuzzyDLKeyword.MIN_VAR_QUERY:
-        queries_list.append(MinQuery(list_tokens[1]))
-    elif list_tokens[0] in (
-        FuzzyDLKeyword.DEFUZZIFY_LOM_QUERY,
-        FuzzyDLKeyword.DEFUZZIFY_SOM_QUERY,
-        FuzzyDLKeyword.DEFUZZIFY_MOM_QUERY,
-    ):
-        c: Concept = _to_concept(kb, list_tokens[1])
-        a: Individual = kb.get_individual(list_tokens[2])
-        role: str = list_tokens[3]
-        if kb.concrete_features.get(role) is None:
-            Util.error(f"Error: Feature {role} has not been defined.")
-        if list_tokens[0] == FuzzyDLKeyword.DEFUZZIFY_LOM_QUERY:
-            queries_list.append(LomDefuzzifyQuery(c, a, role))
-        elif list_tokens[0] == FuzzyDLKeyword.DEFUZZIFY_SOM_QUERY:
-            queries_list.append(SomDefuzzifyQuery(c, a, role))
-        elif list_tokens[0] == FuzzyDLKeyword.DEFUZZIFY_MOM_QUERY:
-            queries_list.append(MomDefuzzifyQuery(c, a, role))
-    elif list_tokens[0] == FuzzyDLKeyword.BNP_QUERY:
-        if not TriangularFuzzyNumber.has_defined_range():
-            Util.error(
-                "Error: The range of the fuzzy numbers has to be defined before being used."
+            _class = (
+                MaxSubsumesQuery
+                if list_tokens[0].lower().startswith("max")
+                else MinSubsumesQuery
             )
-        queries_list.append(BnpQuery(list_tokens[1]))
-    return tokens
-
-
-class DLParser(object):
+            c1: Concept = DLParser._to_concept(list_tokens[1])
+            c2: Concept = DLParser._to_concept(list_tokens[2])
+            if list_tokens[0] in (
+                FuzzyDLKeyword.MAX_SUBS_QUERY,
+                FuzzyDLKeyword.MIN_SUBS_QUERY,
+            ):
+                if DLParser.kb.get_logic() == FuzzyLogic.LUKASIEWICZ:
+                    DLParser.queries_list.append(
+                        _class(c1, c2, LogicOperatorType.LUKASIEWICZ)
+                    )
+                else:
+                    DLParser.queries_list.append(
+                        _class(c1, c2, LogicOperatorType.ZADEH)
+                    )
+            elif list_tokens[0] in (
+                FuzzyDLKeyword.MAX_G_SUBS_QUERY,
+                FuzzyDLKeyword.MIN_G_SUBS_QUERY,
+            ):
+                DLParser.queries_list.append(_class(c1, c2, LogicOperatorType.GOEDEL))
+            elif list_tokens[0] in (
+                FuzzyDLKeyword.MAX_L_SUBS_QUERY,
+                FuzzyDLKeyword.MIN_L_SUBS_QUERY,
+            ):
+                DLParser.queries_list.append(
+                    _class(c1, c2, LogicOperatorType.LUKASIEWICZ)
+                )
+            elif list_tokens[0] in (
+                FuzzyDLKeyword.MAX_KD_SUBS_QUERY,
+                FuzzyDLKeyword.MIN_KD_SUBS_QUERY,
+            ):
+                DLParser.queries_list.append(
+                    _class(c1, c2, LogicOperatorType.KLEENE_DIENES)
+                )
+        elif list_tokens[0] in (
+            FuzzyDLKeyword.MAX_RELATED_QUERY,
+            FuzzyDLKeyword.MIN_RELATED_QUERY,
+        ):
+            a: Individual = DLParser.kb.get_individual(list_tokens[1])
+            b: Individual = DLParser.kb.get_individual(list_tokens[2])
+            role: str = list_tokens[3]
+            if role in DLParser.kb.concrete_roles:
+                Util.error(f"Error: Role {role} cannot be concrete and abstract.")
+            DLParser.kb.abstract_roles.add(role)
+            if list_tokens[0] == FuzzyDLKeyword.MAX_RELATED_QUERY:
+                DLParser.queries_list.append(MaxRelatedQuery(a, b, role))
+            else:
+                DLParser.queries_list.append(MinRelatedQuery(a, b, role))
+        elif list_tokens[0] == FuzzyDLKeyword.MAX_VAR_QUERY:
+            DLParser.queries_list.append(MaxQuery(list_tokens[1]))
+        elif list_tokens[0] == FuzzyDLKeyword.MIN_VAR_QUERY:
+            DLParser.queries_list.append(MinQuery(list_tokens[1]))
+        elif list_tokens[0] in (
+            FuzzyDLKeyword.DEFUZZIFY_LOM_QUERY,
+            FuzzyDLKeyword.DEFUZZIFY_SOM_QUERY,
+            FuzzyDLKeyword.DEFUZZIFY_MOM_QUERY,
+        ):
+            c: Concept = DLParser._to_concept(list_tokens[1])
+            a: Individual = DLParser.kb.get_individual(list_tokens[2])
+            role: str = list_tokens[3]
+            if DLParser.kb.concrete_features.get(role) is None:
+                Util.error(f"Error: Feature {role} has not been defined.")
+            if list_tokens[0] == FuzzyDLKeyword.DEFUZZIFY_LOM_QUERY:
+                DLParser.queries_list.append(LomDefuzzifyQuery(c, a, role))
+            elif list_tokens[0] == FuzzyDLKeyword.DEFUZZIFY_SOM_QUERY:
+                DLParser.queries_list.append(SomDefuzzifyQuery(c, a, role))
+            elif list_tokens[0] == FuzzyDLKeyword.DEFUZZIFY_MOM_QUERY:
+                DLParser.queries_list.append(MomDefuzzifyQuery(c, a, role))
+        elif list_tokens[0] == FuzzyDLKeyword.BNP_QUERY:
+            if not TriangularFuzzyNumber.has_defined_range():
+                Util.error(
+                    "Error: The range of the fuzzy numbers has to be defined before being used."
+                )
+            DLParser.queries_list.append(
+                BnpQuery(
+                    list_tokens[1]
+                    if isinstance(list_tokens[1], TriangularFuzzyNumber)
+                    else DLParser.kb.fuzzy_numbers.get(list_tokens[1])
+                )
+            )
+        return tokens
 
     @staticmethod
-    def get_grammatics(
-        kb: KnowledgeBase, queries_list: list[Query]
-    ) -> pp.ParserElement:
+    def get_grammatics() -> pp.ParserElement:
         """
         This function generate the grammatics to parse the predicate wih formula "formula".
 
@@ -1253,7 +1465,7 @@ class DLParser(object):
         numbers = (
             pp.Combine(pp.Opt(pp.one_of(["+", "-"])) + digits + pp.Opt("." + digits))
             .set_results_name("number", list_all_matches=True)
-            .set_parse_action(_to_number)
+            .set_parse_action(DLParser._to_number)
         )
 
         simple_string = pp.Word(pp.alphas + "_", pp.alphanums + "_'").set_results_name(
@@ -1280,7 +1492,7 @@ class DLParser(object):
                 + rbrace
             )
             .set_results_name("fuzzy_logics", list_all_matches=True)
-            .add_parse_action(partial(_fuzzy_logic_parser, kb))
+            .add_parse_action(DLParser._fuzzy_logic_parser)
         )
 
         comment_line = (comment + any_not_newline).set_results_name(
@@ -1292,13 +1504,19 @@ class DLParser(object):
         weighted_concept_part = (
             (lbrace + numbers + concept + rbrace)
             .set_results_name("simple_weighted_concepts_single", list_all_matches=True)
-            .set_parse_action(partial(_parse_weighted_concept_simple, kb))
+            .set_parse_action(DLParser._parse_weighted_concept_simple)
         )
 
         simple_fuzzy_number = (
-            (variables | lbrace + numbers[3] + rbrace | numbers)
+            (
+                variables
+                | lbrace
+                + (numbers[3] | pp.DelimitedList(numbers, min=3, max=3))
+                + rbrace
+                | numbers
+            )
             .set_results_name("simple_fuzzy_numbers", list_all_matches=True)
-            .set_parse_action(partial(_create_fuzzy_number, kb))
+            .set_parse_action(DLParser._create_fuzzy_number)
         )
 
         fuzzy_number_expr = pp.Forward()
@@ -1311,7 +1529,7 @@ class DLParser(object):
                     FuzzyDLKeyword.FEATURE_MUL.get_name(),
                 ]
             )
-            + pp.OneOrMore(fuzzy_number_expr)
+            + fuzzy_number_expr[1, ...]
             + rbrace
             | lbrace
             + pp.one_of(
@@ -1333,19 +1551,53 @@ class DLParser(object):
                 + rbrace
             )
             .set_results_name("fuzzy_numbers", list_all_matches=True)
-            .set_parse_action(partial(_set_fuzzy_number, kb))
+            .set_parse_action(DLParser._set_fuzzy_number)
         )
 
-        datatype_restriction_function = (
+        datatype_restriction_operand = pp.Forward()
+        datatype_restriction_function = pp.Forward()
+
+        datatype_restriction_mul_expressions = pp.Group(
             (
-                variables
+                lbrace
+                + numbers
+                + pp.Opt(FuzzyDLKeyword.MUL.get_value()).suppress()
+                + datatype_restriction_function
+                + rbrace
+            )
+            .set_results_name("restrictions", list_all_matches=True)
+            .set_parse_action(DLParser._parse_restrictions)
+        )
+        datatype_restriction_sub_expressions = pp.Group(
+            (
+                lbrace
+                + datatype_restriction_function
+                + FuzzyDLKeyword.SUB.get_value()
+                + datatype_restriction_function
+                + rbrace
+            )
+            .set_results_name("restrictions", list_all_matches=True)
+            .set_parse_action(DLParser._parse_restrictions)
+        )
+        datatype_restriction_operand <<= (
+            (
+                datatype_restriction_mul_expressions
+                | datatype_restriction_sub_expressions
+                | variables
                 | numbers
-                | numbers + pp.Opt(FuzzyDLKeyword.MUL.get_value()) + variables
-                | variables + FuzzyDLKeyword.SUB.get_value() + variables
-                | pp.DelimitedList(variables, delim=FuzzyDLKeyword.SUM.get_name())
             )
             .set_results_name("restrictions", list_all_matches=True)
-            .set_parse_action(partial(_parse_restrictions, kb))
+            .set_parse_action(DLParser._parse_restrictions)
+        )
+        datatype_restriction_function <<= (
+            pp.infix_notation(
+                datatype_restriction_operand,
+                [
+                    (FuzzyDLKeyword.SUM.get_value(), 2, pp.OpAssoc.LEFT),
+                ],
+            )
+            .set_results_name("restrictions", list_all_matches=True)
+            .set_parse_action(DLParser._parse_restrictions)
         )
 
         datatype_restrictions = (
@@ -1363,7 +1615,7 @@ class DLParser(object):
                 + rbrace
             )
             .set_results_name("datatype_restrictions", list_all_matches=True)
-            .set_parse_action(partial(_parse_datatype_restriction, kb))
+            .set_parse_action(DLParser._parse_datatype_restriction)
         )
 
         concept <<= (
@@ -1373,7 +1625,7 @@ class DLParser(object):
                 | FuzzyDLKeyword.BOTTOM.get_value()
             )
             .set_results_name("truth_constants", list_all_matches=True)
-            .set_parse_action(partial(_to_top_bottom_concept, kb))
+            .set_parse_action(DLParser._to_top_bottom_concept)
             | datatype_restrictions.set_results_name(
                 "restriction_concepts", list_all_matches=True
             )
@@ -1384,30 +1636,32 @@ class DLParser(object):
             + (
                 (
                     (
-                        pp.one_of(
+                        pp.Literal("[").suppress()
+                        + pp.one_of(
                             [
                                 FuzzyDLKeyword.LESS_THAN_OR_EQUAL_TO.get_name(),
                                 FuzzyDLKeyword.GREATER_THAN_OR_EQUAL_TO.get_name(),
                             ]
                         )
                         + (variables | numbers)
+                        + pp.Literal("]").suppress()
                         + concept
                     )
                     .set_results_name("threshold_concepts", list_all_matches=True)
-                    .set_parse_action(partial(_parse_threshold_concept, kb))
+                    .set_parse_action(DLParser._parse_threshold_concept)
                     | (
                         pp.one_of(
                             [
-                                FuzzyDLKeyword.AND.get_name(),
                                 FuzzyDLKeyword.GOEDEL_AND.get_name(),
                                 FuzzyDLKeyword.LUKASIEWICZ_AND.get_name(),
-                                FuzzyDLKeyword.OR.get_name(),
+                                FuzzyDLKeyword.AND.get_name(),
                                 FuzzyDLKeyword.GOEDEL_OR.get_name(),
                                 FuzzyDLKeyword.LUKASIEWICZ_OR.get_name(),
-                                FuzzyDLKeyword.IMPLIES.get_name(),
+                                FuzzyDLKeyword.OR.get_name(),
                                 FuzzyDLKeyword.GOEDEL_IMPLIES.get_name(),
                                 FuzzyDLKeyword.LUKASIEWICZ_IMPLIES.get_name(),
                                 FuzzyDLKeyword.KLEENE_DIENES_IMPLIES.get_name(),
+                                FuzzyDLKeyword.IMPLIES.get_name(),
                             ]
                         )
                         + concept[2, ...]
@@ -1418,7 +1672,7 @@ class DLParser(object):
                         + (variables | concept)
                     ).set_results_name("some_concepts", list_all_matches=True)
                     | (
-                        FuzzyDLKeyword.HAS_VALUE.get_value() + variables + variables
+                        FuzzyDLKeyword.HAS_VALUE.get_value() + variables[2]
                     ).set_results_name("has_value_concepts", list_all_matches=True)
                     | pp.one_of(
                         [
@@ -1435,16 +1689,16 @@ class DLParser(object):
                     + concept
                 )
                 .set_results_name("binary_concepts", list_all_matches=True)
-                .set_parse_action(partial(_parse_binary_concept, kb))
+                .set_parse_action(DLParser._parse_binary_concept)
                 | (
                     FuzzyDLKeyword.NOT.get_value() + concept
                     | FuzzyDLKeyword.SELF.get_value() + variables
                 )
                 .set_results_name("unary_concepts", list_all_matches=True)
-                .set_parse_action(partial(_parse_unary_concept, kb))
+                .set_parse_action(DLParser._parse_unary_concept)
                 | (variables + concept)
                 .set_results_name("modifier_concepts", list_all_matches=True)
-                .set_parse_action(partial(_parse_modifier_concept, kb))
+                .set_parse_action(DLParser._parse_modifier_concept)
                 | (
                     pp.one_of(
                         [
@@ -1457,14 +1711,14 @@ class DLParser(object):
                     + pp.OneOrMore(weighted_concept_part)
                 )
                 .set_results_name("weighted_concepts", list_all_matches=True)
-                .set_parse_action(partial(_parse_weighted_concept, kb))
+                .set_parse_action(DLParser._parse_weighted_concept)
                 | (
                     FuzzyDLKeyword.Q_OWA.get_value().suppress()
                     + variables
-                    + pp.OneOrMore(concept)
+                    + concept[1, ...]
                 )
                 .set_results_name("q_owas", list_all_matches=True)
-                .set_parse_action(partial(_parse_q_owa_concept, kb))
+                .set_parse_action(DLParser._parse_q_owa_concept)
                 | (
                     pp.one_of(
                         [
@@ -1475,14 +1729,14 @@ class DLParser(object):
                         ]
                     )
                     + lbrace
-                    + pp.OneOrMore(numbers)
+                    + numbers[1, ...]
                     + rbrace
                     + lbrace
-                    + pp.OneOrMore(concept)
+                    + concept[1, ...]
                     + rbrace
                 )
                 .set_results_name("owa_integrals", list_all_matches=True)
-                .set_parse_action(partial(_parse_owa_integral_concept, kb))
+                .set_parse_action(DLParser._parse_owa_integral_concept)
             )
             + rbrace
         )
@@ -1499,25 +1753,25 @@ class DLParser(object):
                     + rbrace
                     | FuzzyDLKeyword.TRIANGULAR_MODIFIER.get_value()
                     + lbrace
-                    + numbers[3]
+                    + (numbers[3] | pp.DelimitedList(numbers, min=3, max=3))
                     + rbrace
                 )
                 + rbrace
             )
             .set_results_name("modifiers", list_all_matches=True)
-            .set_parse_action(partial(_parse_modifier, kb))
+            .set_parse_action(DLParser._parse_modifier)
         )
 
         truth_constants = (
             (
                 lbrace
-                + FuzzyDLKeyword.DEFINE_TRUTH_CONSTANT.get_value()
+                + FuzzyDLKeyword.DEFINE_TRUTH_CONSTANT.get_value().suppress()
                 + variables
                 + numbers
                 + rbrace
             )
             .set_results_name("truth_concepts", list_all_matches=True)
-            .set_parse_action(partial(_parse_truth_constants, kb))
+            .set_parse_action(DLParser._parse_truth_constants)
         )
 
         fuzzy_concept = (
@@ -1558,7 +1812,7 @@ class DLParser(object):
                 + rbrace
             )
             .set_results_name("fuzzy_concepts", list_all_matches=True)
-            .set_parse_action(partial(_parse_fuzzy_concept, kb))
+            .set_parse_action(DLParser._parse_fuzzy_concept)
         )
 
         fuzzy_range = (
@@ -1569,7 +1823,7 @@ class DLParser(object):
                 + rbrace
             )
             .set_results_name("fuzzy_ranges", list_all_matches=True)
-            .set_parse_action(partial(_parse_fuzzy_number_range, kb))
+            .set_parse_action(DLParser._parse_fuzzy_number_range)
         )
 
         features = (
@@ -1598,15 +1852,29 @@ class DLParser(object):
                 + rbrace
             )
             .set_results_name("features", list_all_matches=True)
-            .set_parse_action(partial(_parse_feature, kb))
+            .set_parse_action(DLParser._parse_feature)
+        )
+
+        term = (
+            pp.infix_notation(
+                numbers | variables,
+                [
+                    (FuzzyDLKeyword.MUL.get_value(), 2, pp.OpAssoc.LEFT),
+                ],
+            )
+            .set_results_name("term", list_all_matches=True)
+            .set_parse_action(DLParser._parse_term)
         )
 
         expression = (
-            pp.DelimitedList(
-                numbers + FuzzyDLKeyword.MUL.get_value() + variables, delim="+"
+            # pp.DelimitedList(
+            #     numbers + FuzzyDLKeyword.MUL.get_value() + variables, delim="+"
+            # )
+            pp.infix_notation(
+                term, [(FuzzyDLKeyword.SUM.get_value(), 2, pp.OpAssoc.LEFT)]
             )
             .set_results_name("expressions", list_all_matches=True)
-            .set_parse_action(partial(_parse_expression, kb))
+            .set_parse_action(DLParser._parse_expression)
         )
 
         inequation = (
@@ -1622,119 +1890,118 @@ class DLParser(object):
                 + numbers
             )
             .set_results_name("inequations", list_all_matches=True)
-            .set_parse_action(partial(_parse_inequation, kb))
+            .set_parse_action(DLParser._parse_inequation)
         )
 
         constraints = (
             (
                 lbrace
+                + FuzzyDLKeyword.CONSTRAINTS.get_value()
+                + lbrace
                 + (
                     inequation
                     | FuzzyDLKeyword.BINARY.get_value() + variables
                     | FuzzyDLKeyword.FREE.get_value() + variables
                 )
                 + rbrace
+                + rbrace
             )
             .set_results_name("constraints", list_all_matches=True)
-            .set_parse_action(partial(_parse_constraints, kb))
+            .set_parse_action(DLParser._parse_constraints)
         )
 
         show_concrete_fillers = (
             (
                 lbrace
                 + FuzzyDLKeyword.SHOW_CONCRETE_FILLERS.get_value().suppress()
-                + pp.OneOrMore(variables)
+                + variables[1, ...]
                 + rbrace
             )
             .set_results_name("show_concrete_fillers", list_all_matches=True)
-            .set_parse_action(partial(_show_concrete_fillers, kb))
+            .set_parse_action(DLParser._show_concrete_fillers)
         )
 
         show_concrete_fillers_for = (
             (
                 lbrace
                 + FuzzyDLKeyword.SHOW_CONCRETE_FILLERS_FOR.get_value().suppress()
-                + variables
-                + pp.OneOrMore(variables)
+                + variables[2, ...]
                 + rbrace
             )
             .set_results_name("show_concrete_fillers_for", list_all_matches=True)
-            .set_parse_action(partial(_show_concrete_fillers_for, kb))
+            .set_parse_action(DLParser._show_concrete_fillers_for)
         )
 
         show_concrete_instance_for = (
             (
                 lbrace
                 + FuzzyDLKeyword.SHOW_CONCRETE_INSTANCE_FOR.get_value().suppress()
-                + variables
-                + variables
-                + pp.OneOrMore(variables)
+                + variables[3, ...]
                 + rbrace
             )
             .set_results_name("show_concrete_instance_for", list_all_matches=True)
-            .set_parse_action(partial(_show_concrete_instance_for, kb))
+            .set_parse_action(DLParser._show_concrete_instance_for)
         )
 
         show_abstract_fillers = (
             (
                 lbrace
                 + FuzzyDLKeyword.SHOW_ABSTRACT_FILLERS.get_value().suppress()
-                + pp.OneOrMore(variables)
+                + variables[1, ...]
                 + rbrace
             )
             .set_results_name("show_abstract_fillers", list_all_matches=True)
-            .set_parse_action(partial(_show_abstract_fillers, kb))
+            .set_parse_action(DLParser._show_abstract_fillers)
         )
 
         show_abstract_fillers_for = (
             (
                 lbrace
                 + FuzzyDLKeyword.SHOW_ABSTRACT_FILLERS_FOR.get_value().suppress()
-                + variables
-                + pp.OneOrMore(variables)
+                + variables[2, ...]
                 + rbrace
             )
             .set_results_name("show_abstract_fillers_for", list_all_matches=True)
-            .set_parse_action(partial(_show_abstract_fillers_for, kb))
+            .set_parse_action(DLParser._show_abstract_fillers_for)
         )
 
         show_concepts = (
             (
                 lbrace
                 + FuzzyDLKeyword.SHOW_CONCEPTS.get_value().suppress()
-                + pp.OneOrMore(variables)
+                + variables[1, ...]
                 + rbrace
             )
             .set_results_name("show_concepts", list_all_matches=True)
-            .set_parse_action(partial(_show_concepts, kb))
+            .set_parse_action(DLParser._show_concepts)
         )
 
         show_instances = (
             (
                 lbrace
                 + FuzzyDLKeyword.SHOW_INSTANCES.get_value().suppress()
-                + pp.OneOrMore(concept)
+                + concept[1, ...]
                 + rbrace
             )
             .set_results_name("show_instances", list_all_matches=True)
-            .set_parse_action(partial(_show_instances, kb))
+            .set_parse_action(DLParser._show_instances)
         )
 
         show_variables = (
             (
                 lbrace
                 + FuzzyDLKeyword.SHOW_VARIABLES.get_value().suppress()
-                + pp.OneOrMore(variables)
+                + variables[1, ...]
                 + rbrace
             )
             .set_results_name("show_variables", list_all_matches=True)
-            .set_parse_action(partial(_show_variables, kb))
+            .set_parse_action(DLParser._show_variables)
         )
 
         show_languages = (
             (lbrace + FuzzyDLKeyword.SHOW_LANGUAGE.get_value().suppress() + rbrace)
             .set_results_name("show_languages", list_all_matches=True)
-            .set_parse_action(partial(_show_languages, kb))
+            .set_parse_action(DLParser._show_languages)
         )
 
         show_statements = (
@@ -1756,11 +2023,11 @@ class DLParser(object):
                     FuzzyDLKeyword.CRISP_CONCEPT.get_value()
                     | FuzzyDLKeyword.CRISP_ROLE.get_value()
                 )
-                + pp.OneOrMore(variables)
+                + variables[1, ...]
                 + rbrace
             )
             .set_results_name("crisp_declarations", list_all_matches=True)
-            .set_parse_action(partial(_parse_crisp_declarations, kb))
+            .set_parse_action(DLParser._parse_crisp_declarations)
         )
 
         fuzzy_similarity = (
@@ -1771,7 +2038,7 @@ class DLParser(object):
                 + rbrace
             )
             .set_results_name("fuzzy_similarities", list_all_matches=True)
-            .set_parse_action(partial(_parse_fuzzy_similarity, kb))
+            .set_parse_action(DLParser._parse_fuzzy_similarity)
         )
 
         fuzzy_equivalence = (
@@ -1782,13 +2049,13 @@ class DLParser(object):
                 + rbrace
             )
             .set_results_name("fuzzy_equivalences", list_all_matches=True)
-            .set_parse_action(partial(_parse_fuzzy_equivalence, kb))
+            .set_parse_action(DLParser._parse_fuzzy_equivalence)
         )
 
         degree = (
             (numbers | expression | variables)
             .set_results_name("degrees", list_all_matches=True)
-            .set_parse_action(partial(_parse_degree, kb))
+            .set_parse_action(DLParser._parse_degree)
         )
 
         axioms = (
@@ -1799,34 +2066,29 @@ class DLParser(object):
                     + variables
                     + concept
                     + pp.Opt(degree)
-                    | FuzzyDLKeyword.RELATED.get_value()
-                    + variables
-                    + variables
-                    + variables
-                    + pp.Opt(degree)
+                    | FuzzyDLKeyword.RELATED.get_value() + variables[3] + pp.Opt(degree)
                     | FuzzyDLKeyword.IMPLIES_ROLE.get_value()
-                    + variables
-                    + variables
+                    + variables[2]
                     + pp.Opt(numbers)
                     | FuzzyDLKeyword.ZADEH_IMPLIES.get_value() + concept + concept
                     | pp.one_of(
                         [
+                            FuzzyDLKeyword.ZADEH_IMPLIES.get_name(),
                             FuzzyDLKeyword.GOEDEL_IMPLIES.get_name(),
                             FuzzyDLKeyword.LUKASIEWICZ_IMPLIES.get_name(),
                             FuzzyDLKeyword.KLEENE_DIENES_IMPLIES.get_name(),
                             FuzzyDLKeyword.IMPLIES.get_name(),
                         ]
                     )
-                    + concept
-                    + concept
+                    + concept[2]
                     + pp.Opt(degree)
                     | FuzzyDLKeyword.DEFINE_CONCEPT.get_value() + variables + concept
                     | FuzzyDLKeyword.DEFINE_PRIMITIVE_CONCEPT.get_value()
                     + variables
                     + concept
-                    | FuzzyDLKeyword.EQUIVALENT_CONCEPTS.get_value() + concept + concept
-                    | FuzzyDLKeyword.DISJOINT_UNION.get_value() + pp.OneOrMore(concept)
-                    | FuzzyDLKeyword.DISJOINT.get_value() + pp.OneOrMore(concept)
+                    | FuzzyDLKeyword.EQUIVALENT_CONCEPTS.get_value() + concept[2]
+                    | FuzzyDLKeyword.DISJOINT_UNION.get_value() + concept[1, ...]
+                    | FuzzyDLKeyword.DISJOINT.get_value() + concept[1, ...]
                     | FuzzyDLKeyword.RANGE.get_value() + variables + concept
                     | FuzzyDLKeyword.DOMAIN.get_value() + variables + concept
                     | pp.one_of(
@@ -1839,12 +2101,12 @@ class DLParser(object):
                         ]
                     )
                     + variables
-                    | FuzzyDLKeyword.INVERSE.get_value() + variables + variables,
+                    | FuzzyDLKeyword.INVERSE.get_value() + variables[2],
                 )
                 + rbrace
             )
             .set_results_name("axioms", list_all_matches=True)
-            .set_parse_action(partial(_parse_axioms, kb))
+            .set_parse_action(DLParser._parse_axioms)
         )
 
         queries = (
@@ -1873,17 +2135,14 @@ class DLParser(object):
                             FuzzyDLKeyword.MIN_KD_SUBS_QUERY.get_name(),
                         ]
                     )
-                    + concept
-                    + concept
+                    + concept[2]
                     | pp.one_of(
                         [
                             FuzzyDLKeyword.MAX_RELATED_QUERY.get_name(),
                             FuzzyDLKeyword.MIN_RELATED_QUERY.get_name(),
                         ]
                     )
-                    + variables
-                    + variables
-                    + variables
+                    + variables[3]
                     | pp.one_of(
                         [
                             FuzzyDLKeyword.MAX_SAT_QUERY.get_name(),
@@ -1907,14 +2166,13 @@ class DLParser(object):
                         ]
                     )
                     + concept
-                    + variables
-                    + variables
+                    + variables[2]
                     | FuzzyDLKeyword.BNP_QUERY.get_value() + fuzzy_number_expr,
                 )
                 + rbrace
             )
             .set_results_name("queries", list_all_matches=True)
-            .set_parse_action(partial(_parse_queries, kb, queries_list))
+            .set_parse_action(DLParser._parse_queries)
         )
 
         gformula = (
@@ -1940,32 +2198,26 @@ class DLParser(object):
     @staticmethod
     @utils.recursion_unlimited
     def parse_string(
-        kb: KnowledgeBase,
-        queries: list[Query],
         instring: str,
     ) -> pp.ParseResults:
-        return DLParser.get_grammatics(kb, queries).parse_string(
-            instring, parse_all=True
-        )
+        return DLParser.get_grammatics().parse_string(instring, parse_all=True)
 
     @staticmethod
     @utils.recursion_unlimited
     def parse_string_opt(
-        kb: KnowledgeBase,
-        queries: list[Query],
         filename: str,
     ) -> pp.ParseResults:
         with open(filename, "r") as file:
             instring = file.read()
 
         if ConfigReader.DEBUG_PRINT:
-            return DLParser.get_grammatics(kb, queries).run_tests(
+            return DLParser.get_grammatics().run_tests(
                 instring,
                 failure_tests=True,
                 file=open(os.path.join(LOG_DIR, FILENAME), "w"),
             )
         else:
-            return DLParser.get_grammatics(kb, queries).parse_string(instring)
+            return DLParser.get_grammatics().parse_string(instring)
 
     @staticmethod
     def load_config(*args) -> None:
@@ -1976,22 +2228,25 @@ class DLParser(object):
         try:
             starting_time: float = time.perf_counter_ns()
             DLParser.load_config(*args)
-            kb: KnowledgeBase = KnowledgeBase()
-            queries: list[Query] = []
+            DLParser.kb = KnowledgeBase()
+            DLParser.queries_list = []
             constants.KNOWLEDGE_BASE_SEMANTICS = FuzzyLogic.LUKASIEWICZ
-            # with open(args[0], "r") as file:
-            #     lines = file.readlines()
-            # for line in lines:
-            #     line = line.strip()
-            #     if line == "":
-            #         continue
-            #     if ConfigReader.DEBUG_PRINT:
-            #         Util.debug(f"Line -> {line}")
-            #     _ = DLParser.parse_string(kb, queries, line)
-            _ = DLParser.parse_string_opt(kb, queries, args[0])
+
+            if ConfigReader.DEBUG_PRINT:
+                with open(args[0], "r") as file:
+                    lines = file.readlines()
+                for i, line in enumerate(lines):
+                    line = line.strip()
+                    if line == "":
+                        continue
+                    if ConfigReader.DEBUG_PRINT:
+                        Util.debug(f"Line -> {line}")
+                    _ = DLParser.parse_string(line)
+            else:
+                _ = DLParser.parse_string_opt(args[0])
             ending_time: float = time.perf_counter_ns() - starting_time
             Util.info(f"Knowledge Base parsed in {(ending_time * 1e-9)}s")
-            return kb, queries
+            return DLParser.kb, DLParser.queries_list
         except FileNotFoundError as e:
             Util.error(f"Error: File {args[0]} not found.")
         except Exception as e: