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

fuzzy_dl_owl2/fuzzydl/concept/approximation_concept.py

@@ -1,5 +1,6 @@
 import typing
 
+from fuzzy_dl_owl2.fuzzydl.concept.all_some_concept import AllSomeConcept
 from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
 from fuzzy_dl_owl2.fuzzydl.concept.interface.has_role_concept_interface import (
     HasRoleConceptInterface,
@@ -48,29 +49,52 @@ class ApproximationConcept(Concept, HasRoleConceptInterface):
         self.name = self.compute_name()
 
     @staticmethod
-    def lower_approx(role: str, c: Concept) -> Concept:
+    def lower_approx(role: str, c: Concept) -> typing.Self:
         return ApproximationConcept(ConceptType.LOWER_APPROX, role, c)
 
     @staticmethod
-    def loose_lower_approx(role: str, c: Concept) -> Concept:
+    def loose_lower_approx(role: str, c: Concept) -> typing.Self:
         return ApproximationConcept(ConceptType.LOOSE_LOWER_APPROX, role, c)
 
     @staticmethod
-    def tight_lower_approx(role: str, c: Concept) -> Concept:
+    def tight_lower_approx(role: str, c: Concept) -> typing.Self:
         return ApproximationConcept(ConceptType.TIGHT_LOWER_APPROX, role, c)
 
     @staticmethod
-    def upper_approx(role: str, c: Concept) -> Concept:
+    def upper_approx(role: str, c: Concept) -> typing.Self:
         return ApproximationConcept(ConceptType.UPPER_APPROX, role, c)
 
     @staticmethod
-    def loose_upper_approx(role: str, c: Concept) -> Concept:
+    def loose_upper_approx(role: str, c: Concept) -> typing.Self:
         return ApproximationConcept(ConceptType.LOOSE_UPPER_APPROX, role, c)
 
     @staticmethod
-    def tight_upper_approx(role: str, c: Concept) -> Concept:
+    def tight_upper_approx(role: str, c: Concept) -> typing.Self:
         return ApproximationConcept(ConceptType.TIGHT_UPPER_APPROX, role, c)
 
+    def to_all_some_concept(self) -> AllSomeConcept:
+        if self.type == ConceptType.LOWER_APPROX:
+            return AllSomeConcept.all(self.role, self.curr_concept)
+        if self.type == ConceptType.TIGHT_LOWER_APPROX:
+            return AllSomeConcept.all(
+                self.role, AllSomeConcept.all(self.role, self.curr_concept)
+            )
+        if self.type == ConceptType.LOOSE_LOWER_APPROX:
+            return AllSomeConcept.some(
+                self.role, AllSomeConcept.all(self.role, self.curr_concept)
+            )
+        if self.type == ConceptType.UPPER_APPROX:
+            return AllSomeConcept.some(self.role, self.curr_concept)
+        if self.type == ConceptType.TIGHT_UPPER_APPROX:
+            return AllSomeConcept.all(
+                self.role, AllSomeConcept.some(self.role, self.curr_concept)
+            )
+        if self.type == ConceptType.LOOSE_UPPER_APPROX:
+            return AllSomeConcept.some(
+                self.role, AllSomeConcept.some(self.role, self.curr_concept)
+            )
+        raise ValueError
+
     def clone(self) -> typing.Self:
         return ApproximationConcept(self.type, self.role, self.curr_concept)
 
@@ -111,10 +135,11 @@ class ApproximationConcept(Concept, HasRoleConceptInterface):
             return f"(lla {self.role} {self.curr_concept})"
         elif self.type == ConceptType.UPPER_APPROX:
             return f"(ua {self.role} {self.curr_concept})"
-        elif self.type == ConceptType.LOWER_APPROX:
-            return f"(la {self.role} {self.curr_concept})"
-        elif self.type == ConceptType.LOOSE_UPPER_APPROX:
-            return f"(lua {self.role} {self.curr_concept})"
+        elif self.type == ConceptType.TIGHT_UPPER_APPROX:
+            return f"(tua {self.role} {self.curr_concept})"
+        elif self.type == ConceptType.TIGHT_LOWER_APPROX:
+            return f"(tla {self.role} {self.curr_concept})"
+        raise ValueError
 
     def compute_atomic_concepts(self) -> set[Concept]:
         return self.curr_concept.compute_atomic_concepts()

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

@@ -34,6 +34,7 @@ class TriangularFuzzyNumber(TriangularConcreteConcept):
     def __tringular_fn_init_1(self, name: str, a: float, b: float, c: float) -> None:
         super().__init__(name, self.K1, self.K2, a, b, c)
         self.type = ConceptType.FUZZY_NUMBER
+        self.name = name or self.compute_name()
 
     def __tringular_fn_init_2(self, a: float, b: float, c: float) -> None:
         self.__init__(f"({a}, {b}, {c})", a, b, c)
@@ -76,7 +77,7 @@ class TriangularFuzzyNumber(TriangularConcreteConcept):
         return self.a == self.b == self.c
 
     def compute_name(self) -> str:
-        return f"({self.k1}, {self.k2}, {self.a}, {self.b}, {self.c})"
+        return f"({self.k1}, {self.k2}; {self.a}, {self.b}, {self.c})"
 
     def __add__(self, other: typing.Self) -> typing.Self:
         return TriangularFuzzyNumber(

fuzzy_dl_owl2/fuzzydl/concept/concrete/trapezoidal_concrete_concept.py

@@ -14,6 +14,7 @@ class TrapezoidalConcreteConcept(FuzzyConcreteConcept):
     def __init__(
         self, name: str, k1: float, k2: float, a: float, b: float, c: float, d: float
     ) -> None:
+        super().__init__(name)
         if a > b or b > c or c > d:
             Util.error(f"Error: Trapezoidal functions require {a} <= {b} <= {c} <= {d}")
         if k1 > a:

fuzzy_dl_owl2/fuzzydl/concept/implies_concept.py

@@ -10,10 +10,12 @@ from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import (
     GoedelOr,
     LukasiewiczOr,
     Not,
+    OperatorConcept,
     Or,
 )
 from fuzzy_dl_owl2.fuzzydl.concept.truth_concept import TruthConcept
-from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+from fuzzy_dl_owl2.fuzzydl.util import constants
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType, FuzzyLogic
 from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 
@@ -26,7 +28,6 @@ class ImpliesConcept(Concept, HasConceptsInterface):
         assert c_type in (
             ConceptType.ZADEH_IMPLIES,
             ConceptType.GOEDEL_IMPLIES,
-            ConceptType,
         )
 
         self.name: str = self.compute_name()
@@ -42,8 +43,8 @@ class ImpliesConcept(Concept, HasConceptsInterface):
             return TruthConcept.get_top()
         if c2.type == ConceptType.BOTTOM:
             return -c1
-        # if constants.KNOWLEDGE_BASE_SEMANTICS == FuzzyLogic.CLASSICAL:
-        #     return Or(-c1, c2)
+        if constants.KNOWLEDGE_BASE_SEMANTICS == FuzzyLogic.CLASSICAL:
+            return Or(-c1, c2)
         return LukasiewiczOr(-c1, c2)
 
     @staticmethod
@@ -52,8 +53,8 @@ class ImpliesConcept(Concept, HasConceptsInterface):
             return c2
         if c2.type == ConceptType.TOP or c1.type == ConceptType.BOTTOM:
             return TruthConcept.get_top()
-        # if constants.KNOWLEDGE_BASE_SEMANTICS == FuzzyLogic.CLASSICAL:
-        #     return Or(-c1, c2)
+        if constants.KNOWLEDGE_BASE_SEMANTICS == FuzzyLogic.CLASSICAL:
+            return Or(-c1, c2)
         return GoedelOr(-c1, c2)
 
     @staticmethod
@@ -62,16 +63,18 @@ class ImpliesConcept(Concept, HasConceptsInterface):
             return c2
         if c2.type == ConceptType.TOP or c1.type == ConceptType.BOTTOM:
             return TruthConcept.get_top()
-        # if constants.KNOWLEDGE_BASE_SEMANTICS == FuzzyLogic.CLASSICAL:
-        #     return Or(-c1, c2)
+        if constants.KNOWLEDGE_BASE_SEMANTICS == FuzzyLogic.CLASSICAL:
+            return Or(-c1, c2)
         if c1.type == ConceptType.GOEDEL_OR:
-            return GoedelAnd([GoedelOr(ci, c2) for ci in c1.concepts])
+            return GoedelAnd(
+                [GoedelOr(ci, c2) for ci in typing.cast(OperatorConcept, c1).concepts]
+            )
         return ImpliesConcept(ConceptType.GOEDEL_IMPLIES, [c1, c2])
 
     @staticmethod
     def zadeh_implies(c1: Concept, c2: Concept) -> Concept:
-        # if constants.KNOWLEDGE_BASE_SEMANTICS == FuzzyLogic.CLASSICAL:
-        #     return Or(-c1, c2)
+        if constants.KNOWLEDGE_BASE_SEMANTICS == FuzzyLogic.CLASSICAL:
+            return Or(-c1, c2)
         return ImpliesConcept(ConceptType.ZADEH_IMPLIES, [c1, c2])
 
     def replace(self, a: Concept, c: Concept) -> Concept:

fuzzy_dl_owl2/fuzzydl/concept/operator_concept.py

@@ -360,16 +360,20 @@ class OperatorConcept(Concept, HasConceptsInterface):
             A | A = A
             """
             if OperatorConcept.is_and(self.type):
-                if ConceptType.BOTTOM in [c.type for c in self.concepts] or any(
-                    -c in self.concepts for c in self.concepts
+                if (
+                    ConceptType.BOTTOM in [c.type for c in self.concepts]
+                    or any(-c in self.concepts for c in self.concepts)
+                    and constants.KNOWLEDGE_BASE_SEMANTICS == FuzzyLogic.CLASSICAL
                 ):
                     return TruthConcept.get_bottom()
                 if self.type in OperatorConcept.ABSORPTION_OPERATORS:
                     self.concepts = sorted(set(self.concepts))
                 self.concepts = [c for c in self.concepts if c.type != ConceptType.TOP]
             elif OperatorConcept.is_or(self.type):
-                if ConceptType.TOP in [c.type for c in self.concepts] or any(
-                    -c in self.concepts for c in self.concepts
+                if (
+                    ConceptType.TOP in [c.type for c in self.concepts]
+                    or any(-c in self.concepts for c in self.concepts)
+                    and constants.KNOWLEDGE_BASE_SEMANTICS == FuzzyLogic.CLASSICAL
                 ):
                     return TruthConcept.get_top()
                 if self.type in OperatorConcept.ABSORPTION_OPERATORS:
@@ -458,8 +462,8 @@ class OperatorConcept(Concept, HasConceptsInterface):
                 if a not in [TruthConcept.get_bottom(), TruthConcept.get_top()]
             ]
         )
-        if len(self.concepts) == 1:
-            return self.concepts[0]
+        # if len(self.concepts) == 1:
+        #     return self.concepts[0]
         return OperatorConcept.__op(self.type, self.concepts)
 
     def reduce_quantifiers(self) -> typing.Self:

fuzzy_dl_owl2/fuzzydl/concept/value_concept.py

@@ -15,7 +15,7 @@ class ValueConcept(Concept, HasValueInterface):
         HasValueInterface.__init__(self, role, value)
 
         assert c_type in (
-            ConceptType.AT_LEAST_VALUE,
+            ConceptType.AT_MOST_VALUE,
             ConceptType.AT_LEAST_VALUE,
             ConceptType.EXACT_VALUE,
         )

fuzzy_dl_owl2/fuzzydl/concrete_feature.py

@@ -1,5 +1,6 @@
 import typing
 
+from fuzzy_dl_owl2.fuzzydl.util import constants
 from fuzzy_dl_owl2.fuzzydl.util.constants import ConcreteFeatureType
 
 
@@ -29,7 +30,9 @@ class ConcreteFeature:
         elif len(args) == 3:
             if isinstance(args[1], int) and isinstance(args[2], int):
                 self.__concrete_feature_init_3(*args)
-            elif isinstance(args[1], float) and isinstance(args[2], float):
+            elif isinstance(args[1], constants.NUMBER) and isinstance(
+                args[2], constants.NUMBER
+            ):
                 self.__concrete_feature_init_4(*args)
             else:
                 raise ValueError
@@ -90,5 +93,8 @@ class ConcreteFeature:
     def get_name(self) -> str:
         return self.name
 
+    def __repr__(self) -> str:
+        return str(self)
+
     def __str__(self) -> str:
         return self.get_name()

fuzzy_dl_owl2/fuzzydl/feature_function.py

@@ -13,6 +13,9 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import FeatureFunctionType
 
 class FeatureFunction:
 
+    @typing.overload
+    def __init__(self, feature: typing.Self) -> None: ...
+
     @typing.overload
     def __init__(self, feature: str) -> None: ...
 
@@ -31,7 +34,9 @@ class FeatureFunction:
     def __init__(self, *args) -> None:
         assert len(args) in [1, 2]
         if len(args) == 1:
-            if isinstance(args[0], str):
+            if isinstance(args[0], FeatureFunction):
+                self.__feature_function_init_6(*args)
+            elif isinstance(args[0], str):
                 self.__feature_function_init_1(*args)
             elif isinstance(args[0], constants.NUMBER):
                 self.__feature_function_init_2(*args)
@@ -87,6 +92,12 @@ class FeatureFunction:
         self.feature: str = ""
         self.n: float = n
 
+    def __feature_function_init_6(self, feature: typing.Self) -> None:
+        self.type: FeatureFunctionType = feature.type
+        self.f: list[FeatureFunction] = feature.f
+        self.feature: str = feature.feature
+        self.n: float = feature.n
+
     def get_type(self) -> FeatureFunctionType:
         return self.type
 
@@ -134,6 +145,9 @@ class FeatureFunction:
             return ex1
         return None
 
+    def __repr__(self) -> str:
+        return str(self)
+
     def __str__(self) -> str:
         if self.type == FeatureFunctionType.ATOMIC:
             return self.feature
@@ -144,5 +158,5 @@ class FeatureFunction:
         elif self.type == FeatureFunctionType.SUBTRACTION:
             return f"({self.f[0]} - {self.f[1]})"
         elif self.type == FeatureFunctionType.SUM:
-            return f"({' + '.join(map(str, self.f))}"
+            return f"({' + '.join(map(str, self.f))})"
         return ""

fuzzy_dl_owl2/fuzzydl/fuzzydl_to_owl2.py

@@ -517,7 +517,7 @@ class FuzzydlToOwl2:
         self, value: typing.Union[float, DegreeNumeric]
     ) -> set[OWLAnnotation]:
         """Get annotations for an axiom with degree"""
-        if isinstance(value, float):
+        if isinstance(value, constants.NUMBER):
             n = value
         elif isinstance(value, DegreeNumeric):  # Degree object
             n = value.get_numerical_value()