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

fuzzy_dl_owl2/fuzzydl/concept/concept.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import re
+import typing
+from abc import ABC, abstractmethod
+
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+
+
+class Thing(ABC):
+
+    def is_simplified(self) -> bool:
+        """
+        This function check if current formula is simplified, i.e., if:
+            - The only negated elements are literal of kind (~ A), where A is an AtomicProposition
+            - The OR operator is between:
+                - Two literals => A | B
+                - One literal and a AND => A | (B & C) - (A & B) | C
+                - Two (or more) OR => (A & B) | (C & D) | (E & F)
+            - The AND operator is between:
+                - Two literals => A & B
+                - One literal and a OR => A & (B | C) - (A | B) & C
+                - Two (or more) AND => (A | B) & (C | D) & (E | F)
+            - The only operators are AND, OR and NOT
+        """
+        return True
+
+    def reduce_truth_values(self) -> typing.Self:
+        return self
+
+    def reduce_idempotency(self, is_type: typing.Callable) -> typing.Self:
+        return self
+
+    def reduce_double_negation(self) -> typing.Self:
+        return self
+
+    def distribute(self, c_type: ConceptType) -> typing.Self:
+        return self
+
+    def de_morgan(self) -> typing.Self:
+        return self
+
+    def reduce_quantifiers(self) -> typing.Self:
+        return self
+
+    def normal_form(self, is_type: typing.Callable) -> typing.Self:
+        return self
+
+    def classic_cnf(self) -> typing.Self:
+        return self.normal_form(
+            lambda x: isinstance(x, ConceptType) and x == ConceptType.OR
+        )
+
+    def classic_dnf(self) -> typing.Self:
+        return self.normal_form(
+            lambda x: isinstance(x, ConceptType) and x == ConceptType.AND
+        )
+
+    def goedel_cnf(self) -> typing.Self:
+        return self.normal_form(
+            lambda x: isinstance(x, ConceptType) and x == ConceptType.GOEDEL_OR
+        )
+
+    def goedel_dnf(self) -> typing.Self:
+        return self.normal_form(
+            lambda x: isinstance(x, ConceptType) and x == ConceptType.GOEDEL_AND
+        )
+
+    def lukasiewicz_cnf(self) -> typing.Self:
+        return self.normal_form(
+            lambda x: isinstance(x, ConceptType) and x == ConceptType.LUKASIEWICZ_OR
+        )
+
+    def lukasiewicz_dnf(self) -> typing.Self:
+        return self.normal_form(
+            lambda x: isinstance(x, ConceptType) and x == ConceptType.LUKASIEWICZ_AND
+        )
+
+    @staticmethod
+    def contains_negated_subconcept(v: list[typing.Self], cj: typing.Self) -> int:
+        try:
+            return v.index(-cj)
+        except ValueError:
+            return -1
+
+    @staticmethod
+    def contains_subconcept(v: list[typing.Self], cj: typing.Self) -> bool:
+        return cj in v
+
+    @staticmethod
+    def remove_element(v: list[typing.Self], i: int) -> None:
+        if len(v) > i:
+            v.pop(i)
+
+    def is_concrete(self) -> bool:
+        return False
+
+    @abstractmethod
+    def compute_name(self) -> typing.Optional[str]:
+        pass
+
+    def get_atoms(self) -> list[typing.Self]:
+        return list()
+
+    def get_clauses(self, is_type: typing.Callable) -> list[typing.Self]:
+        return list()
+
+    @abstractmethod
+    def clone(self) -> typing.Self:
+        pass
+
+    @abstractmethod
+    def compute_atomic_concepts(self) -> set[typing.Self]:
+        pass
+
+    def get_atomic_concepts(self) -> set[typing.Self]:
+        return self.compute_atomic_concepts()
+
+    @abstractmethod
+    def get_roles(self) -> set[str]:
+        pass
+
+    @abstractmethod
+    def replace(self, a: typing.Self, c: typing.Self) -> typing.Optional[typing.Self]:
+        pass
+
+    def has_nominals(self) -> bool:
+        return "(b-some " in str(self)
+
+    def __invert__(self) -> typing.Self:
+        return -self
+
+    @abstractmethod
+    def __neg__(self) -> typing.Self:
+        pass
+
+    def __lt__(self, value: typing.Self) -> typing.Self:
+        a, b = re.sub(r"[\(\)]+", "", str(self)), re.sub(r"[\(\)]+", "", str(value))
+        return a < b
+
+    def __le__(self, value: typing.Self) -> typing.Self:
+        return not (self > value)
+
+    def __gt__(self, value: typing.Self) -> typing.Self:
+        a, b = re.sub(r"[\(\)]+", "", str(self)), re.sub(r"[\(\)]+", "", str(value))
+        return a > b
+
+    def __ge__(self, value: typing.Self) -> typing.Self:
+        return not (self < value)
+
+    @abstractmethod
+    def __eq__(self, value: typing.Self) -> bool:
+        pass
+
+    def __ne__(self, value: typing.Self) -> bool:
+        return not (self == value)
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    # def __str__(self) -> str:
+    #     return self.compute_name()
+
+
+class Concept(Thing):
+    SPECIAL_STRING = "@"
+    DEFAULT_NAME = f"Concept{SPECIAL_STRING}"
+    num_new_concepts = 1
+
+    def __init__(
+        self, c_type: ConceptType = ConceptType.ATOMIC, name: str = ""
+    ) -> None:
+        self._type: ConceptType = c_type
+        self._name: str = name
+
+    @property
+    def type(self) -> ConceptType:
+        return self._type
+
+    @type.setter
+    def type(self, new_type: ConceptType) -> None:
+        self._type = new_type
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @name.setter
+    def name(self, value: str) -> None:
+        self._name = value
+
+    def is_atomic(self) -> bool:
+        return self.type == ConceptType.ATOMIC
+
+    def is_complemented_atomic(self) -> bool:
+        return False
+
+    # @abstractmethod
+    def __iand__(self, value: typing.Self) -> typing.Self:
+        pass
+
+    def __and__(self, value: typing.Self) -> typing.Self:
+        pass
+
+    # @abstractmethod
+    def __ior__(self, value: typing.Self) -> typing.Self:
+        pass
+
+    # @abstractmethod
+    def __or__(self, value: typing.Self) -> typing.Self:
+        pass
+
+    # @abstractmethod
+    def __irshift__(self, value: typing.Self) -> typing.Self:
+        pass
+
+    # @abstractmethod
+    def __rshift__(self, value: typing.Self) -> typing.Self:
+        pass
+
+    def __eq__(self, value: typing.Self) -> bool:
+        return str(self) == str(value)
+
+    def __ne__(self, value: typing.Self) -> bool:
+        return not (self == value)
+
+    def __str__(self) -> str:
+        if self.name is None:
+            self.name = self.compute_name()
+        return self.name

fuzzy_dl_owl2/fuzzydl/concept/concrete/__init__.py

@@ -0,0 +1,10 @@
+from .fuzzy_concrete_concept import FuzzyConcreteConcept
+from .crisp_concrete_concept import CrispConcreteConcept
+from .left_concrete_concept import LeftConcreteConcept
+from .right_concrete_concept import RightConcreteConcept
+from .linear_concrete_concept import LinearConcreteConcept
+from .modified_concrete_concept import ModifiedConcreteConcept
+from .trapezoidal_concrete_concept import TrapezoidalConcreteConcept
+from .triangular_concrete_concept import TriangularConcreteConcept
+
+from .fuzzy_number import TriangularFuzzyNumber

fuzzy_dl_owl2/fuzzydl/concept/concrete/crisp_concrete_concept.py

@@ -0,0 +1,60 @@
+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
+
+
+class CrispConcreteConcept(FuzzyConcreteConcept):
+
+    def __init__(self, name: str, k1: float, k2: float, a: float, b: float) -> None:
+        super().__init__(name)
+        self.k1: float = float(k1)
+        self.k2: float = 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 = value
+
+    @property
+    def b(self) -> float:
+        return self._b
+
+    @b.setter
+    def b(self, value: float) -> None:
+        self._b = value
+
+    def clone(self) -> typing.Self:
+        return CrispConcreteConcept(self.name, self.k1, self.k2, self.a, self.b)
+
+    def get_membership_degree(self, x: float) -> float:
+        if self.a <= x <= self.b:
+            return 1.0
+        return 0.0
+
+    def compute_name(self) -> str:
+        return f"crisp({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/fuzzy_concrete_concept.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import typing
+from abc import ABC, abstractmethod
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.exception.fuzzy_ontology_exception import (
+    FuzzyOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+from fuzzy_dl_owl2.fuzzydl.util.util import Util
+
+
+class FuzzyConcreteConcept(Concept, ABC):
+
+    def __init__(self, name: str) -> None:
+        super().__init__(ConceptType.CONCRETE, name)
+        self.name: str = name
+        self._k1: float = 0.0
+        self._k2: float = 0.0
+
+    @property
+    def k1(self) -> float:
+        return self._k1
+
+    @k1.setter
+    def k1(self, value: float) -> None:
+        self._k1 = float(value)
+
+    @property
+    def k2(self) -> float:
+        return self._k2
+
+    @k2.setter
+    def k2(self, value: float) -> None:
+        self._k2 = float(value)
+
+    def compute_name(self) -> str:
+        return self.name
+
+    def is_concrete(self) -> bool:
+        return True
+
+    def compute_atomic_concepts(self) -> set[typing.Self]:
+        return set()
+
+    def get_roles(self) -> set[str]:
+        return set()
+
+    def replace(self, concept1: Concept, concept2: Concept) -> Concept:
+        try:
+            Util.error(f"Error replacing in concept {self}")
+        except FuzzyOntologyException:
+            pass
+        return None
+
+    @abstractmethod
+    def get_membership_degree(self, value: float) -> float:
+        """Get membership degree for a value"""
+        pass
+
+    # def __str__(self) -> str:
+    #     return self.get_name() or self.name

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

@@ -0,0 +1 @@
+from .triangular_fuzzy_number import TriangularFuzzyNumber

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

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.triangular_concrete_concept import (
+    TriangularConcreteConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.util import constants
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+from fuzzy_dl_owl2.fuzzydl.util.util import Util
+
+
+class TriangularFuzzyNumber(TriangularConcreteConcept):
+    K1: float = float("-inf")
+    K2: float = float("inf")
+
+    @typing.overload
+    def __init__(self, name: str, a: float, b: float, c: float) -> None: ...
+
+    @typing.overload
+    def __init__(self, a: float, b: float, c: float) -> None: ...
+
+    def __init__(self, *args) -> None:
+        assert len(args) in [3, 4]
+        if len(args) == 3:
+            assert all(isinstance(a, constants.NUMBER) for a in args)
+            self.__tringular_fn_init_2(*args)
+        else:
+            assert isinstance(args[0], str)
+            assert all(isinstance(a, constants.NUMBER) for a in args[1:])
+            self.__tringular_fn_init_1(*args)
+
+    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
+
+    def __tringular_fn_init_2(self, a: float, b: float, c: float) -> None:
+        self.__init__(f"({a}, {b}, {c})", a, b, c)
+
+    @staticmethod
+    def add(t1: typing.Self, t2: typing.Self) -> typing.Self:
+        return t1 + t2
+
+    @staticmethod
+    def minus(t1: typing.Self, t2: typing.Self) -> typing.Self:
+        return t1 - t2
+
+    @staticmethod
+    def times(t1: typing.Self, t2: typing.Self) -> typing.Self:
+        return t1 * t2
+
+    @staticmethod
+    def divided_by(t1: typing.Self, t2: typing.Self) -> typing.Self:
+        return t1 / t2
+
+    @staticmethod
+    def set_range(min_range: float, max_range: float) -> None:
+        TriangularFuzzyNumber.K1 = min_range
+        TriangularFuzzyNumber.K2 = max_range
+
+    @staticmethod
+    def has_defined_range() -> bool:
+        return TriangularFuzzyNumber.K1 != float("-inf")
+
+    def clone(self) -> typing.Self:
+        return TriangularFuzzyNumber(self.name, self.a, self.b, self.c)
+
+    def is_concrete(self) -> bool:
+        return True
+
+    def get_best_non_fuzzy_performance(self) -> float:
+        return Util.round((self.a + self.b + self.c) / 3.0)
+
+    def is_number(self) -> bool:
+        return self.a == self.b == self.c
+
+    def compute_name(self) -> str:
+        return f"({self.k1}, {self.k2}, {self.a}, {self.b}, {self.c})"
+
+    def __add__(self, other: typing.Self) -> typing.Self:
+        return TriangularFuzzyNumber(
+            self.a + other.a, self.b + other.b, self.c + other.c
+        )
+
+    def __sub__(self, other: typing.Self) -> typing.Self:
+        return TriangularFuzzyNumber(
+            self.a - other.c, self.b - other.b, self.c - other.a
+        )
+
+    def __mul__(self, other: typing.Self) -> typing.Self:
+        return TriangularFuzzyNumber(
+            self.a * other.a, self.b * other.b, self.c * other.c
+        )
+
+    def __truediv__(self, other: typing.Self) -> typing.Self:
+        if 0.0 in (other.a, other.b, other.c):
+            Util.error(
+                f"Error: Cannot divide by zero in fuzzy number ({other.a}, {other.b}, {other.c})."
+            )
+            return None
+        return TriangularFuzzyNumber(
+            self.a / other.c, self.b / other.b, self.c / other.a
+        )
+
+    def __neg__(self) -> TriangularFuzzyNumber:
+        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 __eq__(self, other: typing.Self) -> bool:
+        return (
+            type(self) == type(other)
+            and self.a == other.a
+            and self.b == other.b
+            and self.c == other.c
+        )
+
+    def __ne__(self, other: typing.Self) -> bool:
+        return not (self == other)

fuzzy_dl_owl2/fuzzydl/concept/concrete/left_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 LeftConcreteConcept(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: Left functions require {a} <= {b}")
+        if k1 > a:
+            Util.error(f"Error: Left functions require {k1} <= {a}")
+        if k2 < b:
+            Util.error(f"Error: Left functions require {k2} >= {b}")
+
+        self.k1: float = float(k1)
+        self.k2: float = 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 LeftConcreteConcept(self.name, self.k1, self.k2, self.a, self.b)
+
+    def get_membership_degree(self, value: float) -> float:
+        if value <= self.a:
+            return 0.0
+        if value >= self.b:
+            return 1.0
+        return (self.b - value) / (self.b - self.a)
+
+    def compute_name(self) -> str:
+        return f"left-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.name

fuzzy_dl_owl2/fuzzydl/concept/concrete/linear_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 LinearConcreteConcept(FuzzyConcreteConcept):
+
+    def __init__(self, name: str, k1: float, k2: float, a: float, b: float) -> None:
+        super().__init__(name)
+        if k1 > a:
+            Util.error(f"Error: Left functions require {k1} <= {a}")
+        if b < 1.0:
+            Util.error(f"Error: Left functions require {b} <= 1.0")
+
+        self.k1: float = float(k1)
+        self.k2: float = 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 LinearConcreteConcept(self.name, self.k1, self.k2, self.a, self.b)
+
+    def get_membership_degree(self, value: float) -> float:
+        if value <= 0:
+            return 0.0
+        if value >= 1.0:
+            return 1.0
+        if value <= self.a:
+            return self.b / self.a * value
+        return (value * (1.0 - self.b) + (self.b - self.a)) / (1.0 - self.a)
+
+    def compute_name(self) -> str:
+        return f"linear({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/modified_concrete_concept.py

@@ -0,0 +1,66 @@
+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.modifier.modifier import Modifier
+
+
+class ModifiedConcreteConcept(FuzzyConcreteConcept):
+    def __init__(self, name: str, modifier: Modifier, f: FuzzyConcreteConcept) -> None:
+        super().__init__(name)
+        self.k1: float = 0.0
+        self.k2: float = 1.0
+        self._modifier: Modifier = modifier
+        self._modified: FuzzyConcreteConcept = f
+
+    @property
+    def modifier(self) -> Modifier:
+        return self._modifier
+
+    @modifier.setter
+    def modifier(self, value: Modifier) -> None:
+        self._modifier = value
+
+    @property
+    def modified(self) -> FuzzyConcreteConcept:
+        return self._modified
+
+    @modified.setter
+    def modified(self, value: FuzzyConcreteConcept) -> None:
+        self._modified = value
+
+    def clone(self) -> typing.Self:
+        return ModifiedConcreteConcept(self.name, self.modifier, self.modified)
+
+    # def solve_assertion(
+    #     self, ind: Individual, lower_limit: Degree, kb: KnowledgeBase
+    # ) -> None:
+    #     self.modifier.solve_assertion(ind, self, lower_limit, kb)
+
+    def get_membership_degree(self, x: float) -> float:
+        if x <= 0.0 or x > 1.0:
+            return 0.0
+        y: float = self.modified.get_membership_degree(x)
+        return self.modifier.get_membership_degree(y)
+
+    def compute_name(self) -> str:
+        return f"modified({self.modifier} {self.modified})"
+
+    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()