fuzzy-dl-owl2 1.0.0__py3-none-any.whl

fuzzy_dl_owl2/fuzzydl/concept/concrete/right_concrete_concept.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import typing
+
+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.util.util import Util
+
+
+class RightConcreteConcept(FuzzyConcreteConcept):
+
+    def __init__(self, name: str, k1: float, k2: float, a: float, b: float) -> None:
+        super().__init__(name)
+        if a > b:
+            Util.error(f"Error: Right functions require {a} <= {b}")
+        if k1 > a:
+            Util.error(f"Error: Right functions require {k1} <= {a}")
+        if k2 < b:
+            Util.error(f"Error: Right functions require {k2} >= {b}")
+
+        self.k1: float = k1
+        self.k2: float = k2
+        self._a: float = float(a)
+        self._b: float = float(b)
+
+    @property
+    def a(self) -> float:
+        return self._a
+
+    @a.setter
+    def a(self, value: float) -> None:
+        self._a = float(value)
+
+    @property
+    def b(self) -> float:
+        return self._b
+
+    @b.setter
+    def b(self, value: float) -> None:
+        self._b = float(value)
+
+    def clone(self) -> typing.Self:
+        return RightConcreteConcept(self.name, self.k1, self.k2, self.a, self.b)
+
+    def get_membership_degree(self, x: float) -> float:
+        if x <= self.a:
+            return 0.0
+        if x >= self.b:
+            return 1.0
+        return (x - self.a) / (self.b - self.a)
+
+    def compute_name(self) -> str:
+        return f"right-shoulder({self.k1}, {self.k2}, {self.a}, {self.b})"
+
+    def __neg__(self) -> FuzzyConcreteConcept:
+        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))
+
+    # def __str__(self) -> str:
+    #     return self.get_name()

fuzzy_dl_owl2/fuzzydl/concept/concrete/trapezoidal_concrete_concept.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import typing
+
+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.util.util import Util
+
+
+class TrapezoidalConcreteConcept(FuzzyConcreteConcept):
+
+    def __init__(
+        self, name: str, k1: float, k2: float, a: float, b: float, c: float, d: float
+    ) -> None:
+        if a > b or b > c or c > d:
+            Util.error(f"Error: Trapezoidal functions require {a} <= {b} <= {c} <= {d}")
+        if k1 > a:
+            Util.error(f"Error: Trapezoidal functions require {k1} <= {a}")
+        if k2 < b:
+            Util.error(f"Error: Trapezoidal functions require {k2} >= {b}")
+
+        self.name: str = name
+        self.k1: float = k1
+        self.k2: float = k2
+        self._a: float = float(a)
+        self._b: float = float(b)
+        self._c: float = float(c)
+        self._d: float = float(d)
+
+    @property
+    def a(self) -> float:
+        return self._a
+
+    @a.setter
+    def a(self, value: float) -> None:
+        self._a = float(value)
+
+    @property
+    def b(self) -> float:
+        return self._b
+
+    @b.setter
+    def b(self, value: float) -> None:
+        self._b = float(value)
+
+    @property
+    def c(self) -> float:
+        return self._c
+
+    @c.setter
+    def c(self, value: float) -> None:
+        self._c = float(value)
+
+    @property
+    def d(self) -> float:
+        return self._d
+
+    @d.setter
+    def d(self, value: float) -> None:
+        self._d = float(value)
+
+    def clone(self) -> typing.Self:
+        return TrapezoidalConcreteConcept(
+            self.name, self.k1, self.k2, self.a, self.b, self.c, self.d
+        )
+
+    def get_membership_degree(self, x: float) -> float:
+        if x <= self.a or x >= self.d:
+            return 0.0
+        if self.b <= x <= self.c:
+            return 1.0
+        if x >= self.a:
+            return (x - self.a) / (self.b - self.a)
+        return (self.d - x) / (self.d - self.c)
+
+    def compute_name(self) -> str:
+        return (
+            f"trapezoidal({self.k1}, {self.k2}, {self.a}, {self.b}, {self.c}, {self.d})"
+        )
+
+    def __neg__(self) -> FuzzyConcreteConcept:
+        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))
+
+    # def __str__(self) -> str:
+    #     return self.get_name()

fuzzy_dl_owl2/fuzzydl/concept/concrete/triangular_concrete_concept.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import typing
+
+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.exception.fuzzy_ontology_exception import (
+    FuzzyOntologyException,
+)
+
+
+class TriangularConcreteConcept(FuzzyConcreteConcept):
+    def __init__(
+        self, name: str, k1: float, k2: float, a: float, b: float, c: float
+    ) -> None:
+        super().__init__(name)
+        if a > b or b > c:
+            raise FuzzyOntologyException(
+                f"Error: Triangular functions require {a} <= {b} <= {c}"
+            )
+        if k1 > a:
+            raise FuzzyOntologyException(
+                f"Error: Triangular functions require {k1} <= {a}"
+            )
+        if k2 < b:
+            raise FuzzyOntologyException(
+                f"Error: Triangular functions require {k2} >= {b}"
+            )
+        self.k1: float = k1
+        self.k2: float = k2
+        self._a: float = float(a)
+        self._b: float = float(b)
+        self._c: float = float(c)
+
+    @property
+    def a(self) -> float:
+        return self._a
+
+    @a.setter
+    def a(self, value: float) -> None:
+        self._a = float(value)
+
+    @property
+    def b(self) -> float:
+        return self._b
+
+    @b.setter
+    def b(self, value: float) -> None:
+        self._b = float(value)
+
+    @property
+    def c(self) -> float:
+        return self._c
+
+    @c.setter
+    def c(self, value: float) -> None:
+        self._c = float(value)
+
+    def clone(self) -> typing.Self:
+        return TriangularConcreteConcept(
+            self.name, self.k1, self.k2, self.a, self.b, self.c
+        )
+
+    def get_membership_degree(self, x: float) -> float:
+        if x <= self.a or x >= self.c:
+            return 0.0
+        if x <= self.b:
+            return (x - self.a) / (self.b - self.a)
+        return (self.c - x) / (self.c - self.b)
+
+    def compute_name(self) -> str:
+        return f"triangular({self.k1}, {self.k2}, {self.a}, {self.b}, {self.c})"
+
+    def __neg__(self) -> FuzzyConcreteConcept:
+        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))
+
+    # def __str__(self) -> str:
+    #     return self.get_name()

fuzzy_dl_owl2/fuzzydl/concept/ext_threshold_concept.py

@@ -0,0 +1,77 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_concept_interface import (
+    HasConceptInterface,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+
+
+class ExtThresholdConcept(Concept, HasConceptInterface):
+
+    def __init__(
+        self, c_type: ConceptType, c: Concept, weight_variable: Variable
+    ) -> None:
+        Concept.__init__(self, c_type)
+        HasConceptInterface.__init__(self, c)
+
+        assert c_type in (
+            ConceptType.EXT_POS_THRESHOLD,
+            ConceptType.EXT_NEG_THRESHOLD,
+        )
+        self._weight_variable: Variable = weight_variable
+        self.name: str = self.compute_name()
+
+    @property
+    def weight_variable(self) -> Variable:
+        return self._weight_variable
+
+    @weight_variable.setter
+    def weight_variable(self, value: Variable) -> None:
+        self._weight_variable = value
+
+    @staticmethod
+    def extended_pos_threshold(v: Variable, c: typing.Self) -> typing.Self:
+        return ExtThresholdConcept(ConceptType.EXT_POS_THRESHOLD, c, v)
+
+    @staticmethod
+    def extended_neg_threshold(v: Variable, c: typing.Self) -> typing.Self:
+        return ExtThresholdConcept(ConceptType.EXT_NEG_THRESHOLD, c, v)
+
+    def clone(self):
+        return ExtThresholdConcept(self.type, self.curr_concept, self.weight_variable)
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        return ExtThresholdConcept(
+            self.type, self.curr_concept.replace(a, c), self.weight_variable
+        )
+
+    def compute_name(self) -> typing.Optional[str]:
+        if self.type == ConceptType.EXT_POS_THRESHOLD:
+            return f"([>= {self.weight_variable}] {self.curr_concept})"
+        else:
+            return f"([<= {self.weight_variable}] {self.curr_concept})"
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        return self.curr_concept.compute_atomic_concepts()
+
+    def get_roles(self) -> set[str]:
+        return self.curr_concept.get_roles()
+
+    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))
+
+
+ExtendedPosThreshold = ExtThresholdConcept.extended_pos_threshold
+ExtendedNegThreshold = ExtThresholdConcept.extended_neg_threshold

fuzzy_dl_owl2/fuzzydl/concept/has_value_concept.py

@@ -0,0 +1,51 @@
+import copy
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_value_interface import (
+    HasValueInterface,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+from fuzzy_dl_owl2.fuzzydl.util.util import Util
+
+
+class HasValueConcept(Concept, HasValueInterface):
+
+    def __init__(self, role: str, value: typing.Any) -> None:
+        Concept.__init__(self, ConceptType.HAS_VALUE)
+        HasValueInterface.__init__(self, role, value)
+
+        self.name: str = self.compute_name()
+
+    @staticmethod
+    def has_value(role: str, i: typing.Any) -> typing.Self:
+        return HasValueConcept(role, i)
+
+    def clone(self) -> typing.Self:
+        return HasValueConcept(self.role, copy.deepcopy(self.value))
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        Util.error(f"Error replacing in concept {self}")
+        return None
+
+    def compute_name(self) -> typing.Optional[str]:
+        return f"(b-some {self.role} {self.value})"
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        return set()
+
+    def get_roles(self) -> set[str]:
+        return set()
+
+    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/implies_concept.py

@@ -0,0 +1,144 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_concepts_interface import (
+    HasConceptsInterface,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import (
+    And,
+    GoedelAnd,
+    GoedelOr,
+    LukasiewiczOr,
+    Not,
+    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.util import Util
+
+
+class ImpliesConcept(Concept, HasConceptsInterface):
+
+    def __init__(self, c_type: ConceptType, concepts: list[Concept]) -> None:
+        Concept.__init__(self, c_type)
+        HasConceptsInterface.__init__(self, concepts)
+
+        assert c_type in (
+            ConceptType.ZADEH_IMPLIES,
+            ConceptType.GOEDEL_IMPLIES,
+            ConceptType,
+        )
+
+        self.name: str = self.compute_name()
+
+    def clone(self) -> typing.Self:
+        return ImpliesConcept(self.type, [c for c in self.concepts])
+
+    @staticmethod
+    def lukasiewicz_implies(c1: Concept, c2: Concept) -> Concept:
+        if c1.type == ConceptType.TOP:
+            return c2
+        if c2.type == ConceptType.TOP or c1.type == ConceptType.BOTTOM:
+            return TruthConcept.get_top()
+        if c2.type == ConceptType.BOTTOM:
+            return -c1
+        # if constants.KNOWLEDGE_BASE_SEMANTICS == FuzzyLogic.CLASSICAL:
+        #     return Or(-c1, c2)
+        return LukasiewiczOr(-c1, c2)
+
+    @staticmethod
+    def kleene_dienes_implies(c1: Concept, c2: Concept) -> Concept:
+        if c1.type == ConceptType.TOP:
+            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)
+        return GoedelOr(-c1, c2)
+
+    @staticmethod
+    def goedel_implies(c1: Concept, c2: Concept) -> Concept:
+        if c1.type == ConceptType.TOP:
+            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 c1.type == ConceptType.GOEDEL_OR:
+            return GoedelAnd([GoedelOr(ci, c2) for ci in 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)
+        return ImpliesConcept(ConceptType.ZADEH_IMPLIES, [c1, c2])
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        c_type: ConceptType = c.type
+        if c_type == ConceptType.GOEDEL_IMPLIES:
+            return ImpliesConcept.goedel_implies(
+                self.concepts[0].replace(a, c), self.concepts[1].replace(a, c)
+            )
+        elif c_type == ConceptType.NOT_GOEDEL_IMPLIES:
+            return Not(
+                ImpliesConcept.goedel_implies(
+                    self.concepts[0].replace(a, c), self.concepts[1].replace(a, c)
+                )
+            )
+        Util.error(f"Error replacing in concept {self}")
+
+    def compute_name(self) -> typing.Optional[str]:
+        if self.type == ConceptType.GOEDEL_IMPLIES:
+            return f"(g-implies {self.concepts[0]} {self.concepts[1]})"
+        elif self.type == ConceptType.ZADEH_IMPLIES:
+            return f"(z-implies {self.concepts[0]} {self.concepts[1]})"
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        result: set[Concept] = set()
+        result.update(self.concepts[0].compute_atomic_concepts())
+        result.update(self.concepts[1].compute_atomic_concepts())
+        return result
+
+    def get_roles(self) -> set[str]:
+        return self.concepts[0].get_roles() | self.concepts[1].get_roles()
+
+    def __neg__(self) -> Concept:
+        return Not(self)
+
+    def __and__(self, value: typing.Self) -> typing.Self:
+        return And(self, value)
+
+    def __or__(self, value: typing.Self) -> typing.Self:
+        return Or(self, value)
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, value: typing.Self) -> bool:
+        return isinstance(value, ImpliesConcept) and str(self) == str(value)
+
+
+# class ZadehImplies(ImpliesConcept):
+#     def implies(self, c: Concept) -> typing.Self:
+#         return ImpliesConcept.zadeh_implies(self, c)
+
+
+# class GoedelImplies(ImpliesConcept):
+#     def implies(self, c: Concept) -> typing.Self:
+#         return ImpliesConcept.goedel_implies(self, c)
+
+
+# class LukasiewiczImplies(ImpliesConcept):
+#     def implies(self, c: Concept) -> typing.Self:
+#         return ImpliesConcept.lukasiewicz_implies(self, c)
+
+
+# class KleeneDienesImplies(ImpliesConcept):
+#     def implies(self, c: Concept) -> typing.Self:
+#         return ImpliesConcept.kleene_dienes_implies(self, c)
+
+ZadehImplies = ImpliesConcept.zadeh_implies
+GoedelImplies = ImpliesConcept.goedel_implies
+LukasiewiczImplies = ImpliesConcept.lukasiewicz_implies
+KleeneDienesImplies = ImpliesConcept.kleene_dienes_implies

fuzzy_dl_owl2/fuzzydl/concept/interface/__init__.py

@@ -0,0 +1,6 @@
+from .has_concept_interface import HasConceptInterface
+from .has_concepts_interface import HasConceptsInterface
+from .has_role_interface import HasRoleInterface
+from .has_role_concept_interface import HasRoleConceptInterface
+from .has_value_interface import HasValueInterface
+from .has_weighted_concepts_interface import HasWeightedConceptsInterface

fuzzy_dl_owl2/fuzzydl/concept/interface/has_concept_interface.py

@@ -0,0 +1,17 @@
+import abc
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+
+
+class HasConceptInterface(abc.ABC):
+
+    def __init__(self, concept: Concept) -> None:
+        self._curr_concept: Concept = concept
+
+    @property
+    def curr_concept(self) -> Concept:
+        return self._curr_concept
+
+    @curr_concept.setter
+    def curr_concept(self, value: Concept) -> None:
+        self._curr_concept = value

fuzzy_dl_owl2/fuzzydl/concept/interface/has_concepts_interface.py

@@ -0,0 +1,18 @@
+import abc
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+
+
+class HasConceptsInterface(abc.ABC):
+
+    def __init__(self, concepts: typing.Iterable[Concept]) -> None:
+        self._concepts: list[Concept] = list(concepts)
+
+    @property
+    def concepts(self) -> list[Concept]:
+        return self._concepts
+
+    @concepts.setter
+    def concepts(self, value: typing.Iterable[Concept]) -> None:
+        self._concepts = list(value)

fuzzy_dl_owl2/fuzzydl/concept/interface/has_role_concept_interface.py

@@ -0,0 +1,14 @@
+import abc
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_concept_interface import (
+    HasConceptInterface,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_role_interface import HasRoleInterface
+
+
+class HasRoleConceptInterface(HasRoleInterface, HasConceptInterface, abc.ABC):
+
+    def __init__(self, role: str, concept: Concept) -> None:
+        HasRoleInterface.__init__(self, role)
+        HasConceptInterface.__init__(self, concept)

fuzzy_dl_owl2/fuzzydl/concept/interface/has_role_interface.py

@@ -0,0 +1,15 @@
+import abc
+
+
+class HasRoleInterface(abc.ABC):
+
+    def __init__(self, role: str) -> None:
+        self._role: str = role
+
+    @property
+    def role(self) -> str:
+        return self._role
+
+    @role.setter
+    def role(self, value: str) -> None:
+        self._role = value

fuzzy_dl_owl2/fuzzydl/concept/interface/has_value_interface.py

@@ -0,0 +1,21 @@
+import abc
+import copy
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_role_interface import HasRoleInterface
+
+
+class HasValueInterface(HasRoleInterface, abc.ABC):
+
+    def __init__(self, role: str, value: typing.Any) -> None:
+        super().__init__(role)
+
+        self._value: typing.Any = value
+
+    @property
+    def value(self) -> typing.Any:
+        return self._value
+
+    @value.setter
+    def value(self, value: typing.Any) -> None:
+        self._value = copy.deepcopy(value)

fuzzy_dl_owl2/fuzzydl/concept/interface/has_weighted_concepts_interface.py

@@ -0,0 +1,29 @@
+import abc
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_concepts_interface import (
+    HasConceptsInterface,
+)
+
+
+class HasWeightedConceptsInterface(HasConceptsInterface, abc.ABC):
+
+    def __init__(
+        self,
+        weights: typing.Optional[typing.Iterable[float]],
+        concepts: typing.Iterable[Concept],
+    ) -> None:
+        super().__init__(concepts)
+
+        self._weights: typing.Optional[list[float]] = (
+            list(weights) if weights is not None else None
+        )
+
+    @property
+    def weights(self) -> typing.Optional[list[float]]:
+        return self._weights
+
+    @weights.setter
+    def weights(self, value: typing.Optional[typing.Iterable[float]]) -> None:
+        self._weights = list(value) if value is not None else None

fuzzy_dl_owl2/fuzzydl/concept/modified/__init__.py

@@ -0,0 +1,3 @@
+from .modified_concept import ModifiedConcept
+from .linearly_modified_concept import LinearlyModifiedConcept
+from .triangularly_modified_concept import TriangularlyModifiedConcept