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

fuzzy_dl_owl2/fuzzydl/__init__.py

@@ -10,6 +10,7 @@ from .exception import *
 from .feature_function import FeatureFunction
 from .general_concept_inclusion import GeneralConceptInclusion
 from .individual import *
+from .classification_node import ClassificationNode
 from .knowledge_base import KnowledgeBase
 from .label import Label
 from .modifier import *
@@ -20,4 +21,4 @@ from .range_axiom import RangeAxiom
 from .relation import Relation
 from .restriction import *
 from .role_parent_with_degree import RoleParentWithDegree
-from .fuzzydl_to_owl2 import FuzzydlToOwl2
+from .fuzzydl_to_owl2 import FuzzydlToOwl2

fuzzy_dl_owl2/fuzzydl/assertion/assertion.py

@@ -16,6 +16,7 @@ class Assertion:
     def __init__(self, ind: Individual, c: Concept, d: Degree) -> None:
         self.individual: Individual = ind
         self.concept: Concept = c
+        # Lower bound degree
         self.degree: Degree = d
 
     def clone(self) -> typing.Self:

fuzzy_dl_owl2/fuzzydl/assertion/atomic_assertion.py

@@ -6,7 +6,9 @@ from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
 
 class AtomicAssertion:
     def __init__(self, c: Concept, degree: Degree) -> None:
+        # Atomic concept
         self.c: Concept = c
+        # Lower bound degree
         self.degree: Degree = degree
 
     def get_concept_name(self) -> str:

fuzzy_dl_owl2/fuzzydl/classification_node.py

@@ -0,0 +1,64 @@
+import typing
+
+
+class ClassificationNode:
+    EQUIVALENT_NAMES: set[str] = set()
+    INPUT_EDGES: dict[typing.Self, float] = dict()
+    OUTPUT_EDGES: dict[typing.Self, float] = dict()
+
+    def __init__(self, name: str) -> None:
+        ClassificationNode.EQUIVALENT_NAMES.add(name)
+
+    def is_thing(self) -> bool:
+        return self.has_name("*top*")
+
+    def is_nothing(self) -> bool:
+        return self.has_name("*bottom*")
+
+    def add_input_edge(self, node: typing.Self, n: float) -> None:
+        ClassificationNode.INPUT_EDGES[node] = n
+
+    def add_ouput_edge(self, node: typing.Self, n: float) -> None:
+        ClassificationNode.OUTPUT_EDGES[node] = n
+
+    def remove_input_edge(self, node: typing.Self, n: float) -> None:
+        value: typing.Optional[float] = ClassificationNode.INPUT_EDGES.get(node)
+        if value is not None and value <= n:
+            del ClassificationNode.INPUT_EDGES[node]
+
+    def remove_ouput_edge(self, node: typing.Self, n: float) -> None:
+        value: typing.Optional[float] = ClassificationNode.OUTPUT_EDGES.get(node)
+        if value is not None and value <= n:
+            del ClassificationNode.OUTPUT_EDGES[node]
+
+    def has_name(self, name: str) -> bool:
+        for s in ClassificationNode.EQUIVALENT_NAMES:
+            if s == name:
+                return True
+        return False
+
+    def add_label(self, c: str) -> None:
+        ClassificationNode.EQUIVALENT_NAMES.add(c)
+
+    def get_output_edges() -> dict[typing.Self, float]:
+        return ClassificationNode.OUTPUT_EDGES
+
+    def get_immediate_successors() -> set[typing.Self]:
+        return set(ClassificationNode.INPUT_EDGES.keys())
+
+    def get_immediate_predecessors() -> set[typing.Self]:
+        return set(ClassificationNode.OUTPUT_EDGES.keys())
+
+    def get_full_name(self) -> str:
+        if len(ClassificationNode.EQUIVALENT_NAMES) == 1:
+            return str(self)
+        return f"{{{ ' '.join(name for name in ClassificationNode.EQUIVALENT_NAMES) }}}"
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return list(ClassificationNode.EQUIVALENT_NAMES)[0]

fuzzy_dl_owl2/fuzzydl/concept/__init__.py

@@ -11,3 +11,5 @@ from .weighted_max_concept import WeightedMaxConcept
 from .weighted_min_concept import WeightedMinConcept
 from .weighted_sum_concept import WeightedSumConcept
 from .weighted_sum_zero_concept import WeightedSumZeroConcept
+from .sigma_concept import SigmaConcept
+from .sigma_count import SigmaCount

fuzzy_dl_owl2/fuzzydl/concept/atomic_concept.py

@@ -44,7 +44,7 @@ class AtomicConcept(Concept):
         return AtomicConcept(self.name)
 
     def compute_atomic_concepts(self) -> set[typing.Self]:
-        return [self]
+        return set([self])
 
     def get_roles(self) -> set[str]:
         return set()

fuzzy_dl_owl2/fuzzydl/concept/choquet_integral.py

@@ -12,6 +12,10 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 
 class ChoquetIntegral(Concept, HasWeightedConceptsInterface):
+    """
+    Choquet integral concept.
+    """
+
     def __init__(self, weights: list[float], concepts: list[Concept]) -> None:
         Concept.__init__(self, ConceptType.CHOQUET_INTEGRAL)
         HasWeightedConceptsInterface.__init__(self, weights, concepts)
@@ -22,6 +26,8 @@ class ChoquetIntegral(Concept, HasWeightedConceptsInterface):
                     "Error: The number of weights and the number of concepts should be the same"
                 )
             self.name: str = str(self)
+        else:
+            self.weights = list()
 
     def clone(self) -> typing.Self:
         return ChoquetIntegral(self.weights[:], [c for c in self.concepts])

fuzzy_dl_owl2/fuzzydl/concept/concept.py

@@ -116,6 +116,9 @@ class Thing(ABC):
     def get_atomic_concepts(self) -> set[typing.Self]:
         return self.compute_atomic_concepts()
 
+    def get_atomic_concepts_names(self) -> set[str]:
+        return set([str(concept) for concept in self.compute_atomic_concepts()])
+
     @abstractmethod
     def get_roles(self) -> set[str]:
         pass
@@ -163,14 +166,19 @@ class Thing(ABC):
 
 
 class Concept(Thing):
+    # Used to create new concepts
     SPECIAL_STRING = "@"
+    # Default prefix for new individual names.
     DEFAULT_NAME = f"Concept{SPECIAL_STRING}"
+    # Number of new concepts
     num_new_concepts = 1
 
     def __init__(
         self, c_type: ConceptType = ConceptType.ATOMIC, name: str = ""
     ) -> None:
+        # Type of the concept
         self._type: ConceptType = c_type
+        # Name of the concept
         self._name: str = name
 
     @property

fuzzy_dl_owl2/fuzzydl/concept/concrete/crisp_concrete_concept.py

@@ -9,6 +9,7 @@ from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
 
 
 class CrispConcreteConcept(FuzzyConcreteConcept):
+    """Concrete concept defined with a crisp interval."""
 
     def __init__(self, name: str, k1: float, k2: float, a: float, b: float) -> None:
         super().__init__(name)

fuzzy_dl_owl2/fuzzydl/concept/concrete/fuzzy_concrete_concept.py

@@ -12,6 +12,7 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 
 class FuzzyConcreteConcept(Concept, ABC):
+    """Fuzzy concrete concept defined with an explicit membership function."""
 
     def __init__(self, name: str) -> None:
         super().__init__(ConceptType.CONCRETE, name)

fuzzy_dl_owl2/fuzzydl/concept/concrete/fuzzy_number/triangular_fuzzy_number.py

@@ -12,7 +12,11 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 
 class TriangularFuzzyNumber(TriangularConcreteConcept):
+    """Fuzzy number defined with a triangular function."""
+
+    # Lower bound of the range of the fuzzy numbers.
     K1: float = float("-inf")
+    # Upper bound of the range of the fuzzy numbers.
     K2: float = float("inf")
 
     @typing.overload
@@ -41,18 +45,24 @@ class TriangularFuzzyNumber(TriangularConcreteConcept):
 
     @staticmethod
     def add(t1: typing.Self, t2: typing.Self) -> typing.Self:
+        """
+        Adds two triangular fuzzy numbers.
+        """
         return t1 + t2
 
     @staticmethod
     def minus(t1: typing.Self, t2: typing.Self) -> typing.Self:
+        """Subtracts two triangular fuzzy numbers."""
         return t1 - t2
 
     @staticmethod
     def times(t1: typing.Self, t2: typing.Self) -> typing.Self:
+        """Multiplies two triangular fuzzy numbers."""
         return t1 * t2
 
     @staticmethod
     def divided_by(t1: typing.Self, t2: typing.Self) -> typing.Self:
+        """Divides two triangular fuzzy numbers."""
         return t1 / t2
 
     @staticmethod
@@ -62,6 +72,7 @@ class TriangularFuzzyNumber(TriangularConcreteConcept):
 
     @staticmethod
     def has_defined_range() -> bool:
+        """Checks if the range of the fuzzy numbers has been defined."""
         return TriangularFuzzyNumber.K1 != float("-inf")
 
     def clone(self) -> typing.Self:
@@ -71,6 +82,7 @@ class TriangularFuzzyNumber(TriangularConcreteConcept):
         return True
 
     def get_best_non_fuzzy_performance(self) -> float:
+        """Gets the Best Non fuzzy Performance (BNP) of the fuzzy number."""
         return Util.round((self.a + self.b + self.c) / 3.0)
 
     def is_number(self) -> bool:

fuzzy_dl_owl2/fuzzydl/concept/concrete/left_concrete_concept.py

@@ -10,6 +10,9 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 
 class LeftConcreteConcept(FuzzyConcreteConcept):
+    """
+    Fuzzy concrete concept defined with a left shoulder function
+    """
 
     def __init__(self, name: str, k1: float, k2: float, a: float, b: float) -> None:
         super().__init__(name)

fuzzy_dl_owl2/fuzzydl/concept/concrete/linear_concrete_concept.py

@@ -10,6 +10,9 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 
 class LinearConcreteConcept(FuzzyConcreteConcept):
+    """
+    Fuzzy concrete concept defined with a left shoulder function
+    """
 
     def __init__(self, name: str, k1: float, k2: float, a: float, b: float) -> None:
         super().__init__(name)

fuzzy_dl_owl2/fuzzydl/concept/concrete/modified_concrete_concept.py

@@ -10,6 +10,10 @@ from fuzzy_dl_owl2.fuzzydl.modifier.modifier import Modifier
 
 
 class ModifiedConcreteConcept(FuzzyConcreteConcept):
+    """
+    Modified concrete concept.
+    """
+    
     def __init__(self, name: str, modifier: Modifier, f: FuzzyConcreteConcept) -> None:
         super().__init__(name)
         self.k1: float = 0.0

fuzzy_dl_owl2/fuzzydl/concept/concrete/right_concrete_concept.py

@@ -11,6 +11,8 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 class RightConcreteConcept(FuzzyConcreteConcept):
 
+    """Fuzzy concrete concept defined with a right shoulder function."""
+
     def __init__(self, name: str, k1: float, k2: float, a: float, b: float) -> None:
         super().__init__(name)
         if a > b:

fuzzy_dl_owl2/fuzzydl/concept/concrete/trapezoidal_concrete_concept.py

@@ -10,6 +10,7 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 
 class TrapezoidalConcreteConcept(FuzzyConcreteConcept):
+    """Fuzzy concrete concept defined with a trapezoidal function."""
 
     def __init__(
         self, name: str, k1: float, k2: float, a: float, b: float, c: float, d: float

fuzzy_dl_owl2/fuzzydl/concept/concrete/triangular_concrete_concept.py

@@ -12,6 +12,8 @@ from fuzzy_dl_owl2.fuzzydl.exception.fuzzy_ontology_exception import (
 
 
 class TriangularConcreteConcept(FuzzyConcreteConcept):
+    """Fuzzy concrete concept defined with a triangular function."""
+
     def __init__(
         self, name: str, k1: float, k2: float, a: float, b: float, c: float
     ) -> None:

fuzzy_dl_owl2/fuzzydl/concept/modified/linearly_modified_concept.py

@@ -9,6 +9,9 @@ from fuzzy_dl_owl2.fuzzydl.modifier.modifier import Modifier
 
 
 class LinearlyModifiedConcept(ModifiedConcept):
+    """
+    Fuzzy concept modified with a linear modifier
+    """
 
     def __init__(self, c: Concept, mod: Modifier) -> None:
         super().__init__(c, mod)

fuzzy_dl_owl2/fuzzydl/concept/modified/modified_concept.py

@@ -13,6 +13,9 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
 
 
 class ModifiedConcept(Concept, HasConceptInterface, ABC):
+    """
+    Modified fuzzy concept.
+    """
 
     def __init__(self, c: Concept, mod: Modifier) -> None:
         Concept.__init__(self, ConceptType.MODIFIED)

fuzzy_dl_owl2/fuzzydl/concept/modified/triangularly_modified_concept.py

@@ -9,6 +9,9 @@ from fuzzy_dl_owl2.fuzzydl.modifier.modifier import Modifier
 
 
 class TriangularlyModifiedConcept(ModifiedConcept):
+
+    """Fuzzy concept modified with a triangular modifier."""
+
     def __init__(self, c: Concept, mod: Modifier) -> None:
         super().__init__(c, mod)
 

fuzzy_dl_owl2/fuzzydl/concept/negated_nominal.py

@@ -9,6 +9,9 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
 
 
 class NegatedNominal(Concept):
+    """
+    Negated nominal concept. Only used in range restrictions for the moment.
+    """
 
     def __init__(self, ind_name: str) -> None:
         super().__init__(ConceptType.ATOMIC)

fuzzy_dl_owl2/fuzzydl/concept/operator_concept.py

@@ -12,6 +12,10 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType, FuzzyLogic
 
 
 class OperatorConcept(Concept, HasConceptsInterface):
+    """
+    Defines a logic operator concept defined as AND, OR or NOT of concepts.
+    """
+
     AND_OPERATORS: list[ConceptType] = [
         ConceptType.AND,
         ConceptType.GOEDEL_AND,
@@ -262,6 +266,10 @@ class OperatorConcept(Concept, HasConceptsInterface):
     def is_not_zadeh_implies(op: Concept) -> bool:
         return OperatorConcept.is_not_type(op, ConceptType.ZADEH_IMPLIES)
 
+    @staticmethod
+    def is_not_sigma_concept(op: Concept) -> bool:
+        return OperatorConcept.is_not_type(op, ConceptType.SIGMA_CONCEPT)
+
     def is_concrete(self) -> bool:
         if OperatorConcept.is_not_concrete(self) or OperatorConcept.is_not_fuzzy_number(
             self

fuzzy_dl_owl2/fuzzydl/concept/qowa_concept.py

@@ -10,6 +10,10 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
 
 
 class QowaConcept(OwaConcept):
+    """
+    Quantified-guided OWA concept.
+    """
+
     def __init__(
         self, quantifier: FuzzyConcreteConcept, concepts: list[Concept]
     ) -> None:

fuzzy_dl_owl2/fuzzydl/concept/quasi_sugeno_integral.py

@@ -10,6 +10,9 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 
 class QsugenoIntegral(SugenoIntegral):
+    """
+    Quasi Sugeno integral concept.
+    """
 
     def __init__(self, weights: list[float], concepts: list[Concept]) -> None:
         super().__init__(weights, concepts)

fuzzy_dl_owl2/fuzzydl/concept/sigma_concept.py

@@ -0,0 +1,71 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_concrete_concept import (
+    FuzzyConcreteConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+
+
+class SigmaConcept(Concept):
+    """Sigma-count concept."""
+
+    def __init__(
+        self,
+        concept: Concept,
+        role: str,
+        individuals: list[Individual],
+        concrete_concept: FuzzyConcreteConcept,
+    ) -> None:
+        super().__init__(ConceptType.SIGMA_CONCEPT, "")
+        self.concept: Concept = concept
+        self.role: str = role
+        self.individuals: list[Individual] = individuals
+        self.concrete_concept: FuzzyConcreteConcept = concrete_concept
+        self.name: str = self.compute_name()
+
+    def get_individuals(self) -> list[Individual]:
+        return self.individuals
+
+    def get_concept(self) -> Concept:
+        return self.concept
+
+    def get_role(self) -> str:
+        return self.role
+
+    def get_fuzzy_concept(self) -> FuzzyConcreteConcept:
+        return self.concrete_concept
+
+    def clone(self) -> typing.Self:
+        return SigmaConcept(
+            self.concept.clone(),
+            self.role,
+            [i.clone() for i in self.individuals],
+            self.concrete_concept.clone(),
+        )
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        return set()
+
+    def get_roles(self) -> set[str]:
+        return set()
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        return self
+
+    def compute_name(self) -> str | None:
+        return f"(sigma-count {self.role} {self.concept} {{{' '.join(map(str, self.individuals))}}} {self.concrete_concept})"
+
+    def __neg__(self) -> Concept:
+        return OperatorConcept.not_(self)
+
+    def __and__(self, value: typing.Self) -> typing.Self:
+        return OperatorConcept.and_(self, value)
+
+    def __or__(self, value: typing.Self) -> typing.Self:
+        return OperatorConcept.or_(self, value)
+
+    def __hash__(self) -> int:
+        return hash(str(self))

fuzzy_dl_owl2/fuzzydl/concept/sigma_count.py

@@ -0,0 +1,56 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+
+
+class SigmaCount:
+    """Sigma-count pending tasks."""
+
+    def __init__(
+        self,
+        var: Variable,
+        ind: Individual,
+        inds: list[Individual],
+        role: str,
+        concept: Concept,
+    ) -> None:
+        self.variable: Variable = var
+        self.individual: Individual = ind
+        self.individuals: list[Individual] = inds
+        self.role: str = role
+        self.concept: Concept = concept
+
+    def clone(self) -> typing.Self:
+        return SigmaCount(
+            self.variable.clone(),
+            self.individual.clone(),
+            [i.clone() for i in self.individuals],
+            self.role,
+            self.concept.clone(),
+        )
+
+    def get_variable(self) -> Variable:
+        return self.variable
+
+    def get_individual(self) -> Individual:
+        return self.individual
+
+    def get_individuals(self) -> list[Individual]:
+        return self.individuals
+
+    def get_role(self) -> str:
+        return self.role
+
+    def get_concept(self) -> Concept:
+        return self.concept
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return f"sigma-count({self.variable}, {self.individual}, {self.individuals}, {self.role}, {self.concept})"

fuzzy_dl_owl2/fuzzydl/concept/sugeno_integral.py

@@ -14,6 +14,7 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 
 class SugenoIntegral(Concept, HasWeightedConceptsInterface):
+    """Sugeno integral concept."""
 
     @typing.overload
     def __init__(self) -> None: ...
@@ -48,6 +49,9 @@ class SugenoIntegral(Concept, HasWeightedConceptsInterface):
                     "Error: The number of weights and the number of concepts should be the same"
                 )
             self.name = self.compute_name()
+        else:
+            self.weights: list[float] = []
+
 
     def clone(self) -> typing.Self:
         return SugenoIntegral(self.weights[:], [c for c in self.concepts])

fuzzy_dl_owl2/fuzzydl/concept_equivalence.py

@@ -6,8 +6,13 @@ from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
 
 
 class ConceptEquivalence:
+    """
+    Concept equivalence axiom
+    """
     def __init__(self, c1: Concept, c2: Concept) -> None:
+        # First concept
         self.c1: Concept = c1
+        # Second concept
         self.c2: Concept = c2
 
     def clone(self) -> typing.Self:

fuzzy_dl_owl2/fuzzydl/concrete_feature.py

@@ -41,7 +41,9 @@ class ConcreteFeature:
 
     def __concrete_feature_init_1(self, name: str) -> None:
         self.name: str = name
+        # Lower bound for the range
         self.k1: typing.Optional[typing.Union[float, int]] = None
+        # Upper bound for the range
         self.k2: typing.Optional[typing.Union[float, int]] = None
         self.type: ConcreteFeatureType = ConcreteFeatureType.STRING
 
@@ -52,13 +54,17 @@ class ConcreteFeature:
 
     def __concrete_feature_init_3(self, name: str, k1: int, k2: int) -> None:
         self.__concrete_feature_init_1(name)
+        # Lower bound for the range
         self.k1: typing.Optional[typing.Union[float, int]] = k1
+        # Upper bound for the range
         self.k2: typing.Optional[typing.Union[float, int]] = k2
         self.type: ConcreteFeatureType = ConcreteFeatureType.INTEGER
 
     def __concrete_feature_init_4(self, name: str, k1: float, k2: float) -> None:
         self.__concrete_feature_init_1(name)
+        # Lower bound for the range
         self.k1: typing.Optional[typing.Union[float, int]] = k1
+        # Upper bound for the range
         self.k2: typing.Optional[typing.Union[float, int]] = k2
         self.type: ConcreteFeatureType = ConcreteFeatureType.REAL
 

fuzzy_dl_owl2/fuzzydl/domain_axiom.py

@@ -2,6 +2,9 @@ from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
 
 
 class DomainAxiom:
+    """
+    Role domain axiom
+    """
 
     def __init__(self, role: str, concept: Concept) -> None:
         self.role: str = role

fuzzy_dl_owl2/fuzzydl/feature_function.py

@@ -12,6 +12,7 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import FeatureFunctionType
 
 
 class FeatureFunction:
+    """Function involving several features."""
 
     @typing.overload
     def __init__(self, feature: typing.Self) -> None: ...
@@ -105,6 +106,7 @@ class FeatureFunction:
         return self.n
 
     def get_features(self) -> set[str]:
+        """Gets an array of features that take part in the function."""
         features: set[str] = set()
         if self.type == FeatureFunctionType.ATOMIC:
             features.add(self.feature)
@@ -121,27 +123,34 @@ class FeatureFunction:
     def to_expression(
         self, a: Individual, milp: MILPHelper
     ) -> typing.Optional[Expression]:
+        """Gets an array of features that take part in the function."""
         if self.type == FeatureFunctionType.ATOMIC:
+            # Get the filler "b" for feature(a)
             rel_set: list[Relation] = a.role_relations.get(self.feature)
+            assert len(rel_set) > 0
             b: CreatedIndividual = typing.cast(
                 CreatedIndividual, rel_set[0].get_object_individual()
             )
+            # Get the variable xB
             x_b: Variable = milp.get_variable(b)
             return Expression(Term(1.0, x_b))
         elif self.type == FeatureFunctionType.NUMBER:
             return Expression(self.n)
         elif self.type == FeatureFunctionType.PRODUCT:
+            assert len(self.f) == 1
             ex: Expression = self.f[0].to_expression(a, milp)
-            return Expression.multiply_constant(ex, self.n)
+            return ex * self.n
         elif self.type == FeatureFunctionType.SUBTRACTION:
+            assert len(self.f) == 2
             ex1: Expression = self.f[0].to_expression(a, milp)
             ex2: Expression = self.f[1].to_expression(a, milp)
-            return Expression.subtract_expressions(ex1, ex2)
+            return ex1 - ex2
         elif self.type == FeatureFunctionType.SUM:
+            assert len(self.f) >= 1
             ex1: Expression = self.f[0].to_expression(a, milp)
             for i in range(1, len(self.f)):
                 ex2: Expression = self.f[i].to_expression(a, milp)
-                ex1: Expression = Expression.add_expressions(ex1, ex2)
+                ex1 = ex1 + ex2
             return ex1
         return None
 

fuzzy_dl_owl2/fuzzydl/fuzzydl_to_owl2.py

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