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

fuzzy_dl_owl2/__init__.py

@@ -0,0 +1,2 @@
+from .fuzzydl import *
+from .fuzzyowl2 import *

fuzzy_dl_owl2/fuzzydl/__init__.py

@@ -0,0 +1,23 @@
+from .util import *
+from .milp import *
+from .degree import *
+from .concept import *
+from .assertion import *
+from .concept_equivalence import ConceptEquivalence
+from .concrete_feature import ConcreteFeature
+from .domain_axiom import DomainAxiom
+from .exception import *
+from .feature_function import FeatureFunction
+from .general_concept_inclusion import GeneralConceptInclusion
+from .individual import *
+from .knowledge_base import KnowledgeBase
+from .label import Label
+from .modifier import *
+from .parser import *
+from .primitive_concept_definition import PrimitiveConceptDefinition
+from .query import *
+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

fuzzy_dl_owl2/fuzzydl/assertion/__init__.py

@@ -0,0 +1,2 @@
+from .assertion import Assertion
+from .atomic_assertion import AtomicAssertion

fuzzy_dl_owl2/fuzzydl/assertion/assertion.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
+from fuzzy_dl_owl2.fuzzydl.degree.degree_numeric import DegreeNumeric
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+
+
+class Assertion:
+
+    def __init__(self, ind: Individual, c: Concept, d: Degree) -> None:
+        self.individual: Individual = ind
+        self.concept: Concept = c
+        self.degree: Degree = d
+
+    def clone(self) -> typing.Self:
+        return Assertion(self.individual, self.concept, self.degree)
+
+    def get_type(self) -> ConceptType:
+        return self.concept.type
+
+    def get_lower_limit(self) -> Degree:
+        return self.degree
+
+    def get_concept(self) -> Concept:
+        return self.concept
+
+    def get_individual(self) -> Individual:
+        return self.individual
+
+    def set_individual(self, ind: Individual) -> None:
+        self.individual = ind
+
+    def set_lower_limit(self, deg: Degree) -> None:
+        self.degree = deg
+
+    def get_name_without_degree(self) -> str:
+        return f"{self.individual}:{self.concept}"
+
+    def equals(self, ass: typing.Self) -> bool:
+        return self == ass
+
+    def __eq__(self, value: typing.Self) -> bool:
+        if not isinstance(value, Assertion):
+            return False
+
+        same: bool = False
+        if str(self) == str(value):
+            same = True
+        elif (
+            self.get_name_without_degree() == value.get_name_without_degree()
+            and isinstance(self.get_lower_limit(), DegreeNumeric)
+            and isinstance(value.get_lower_limit(), DegreeNumeric)
+            and typing.cast(DegreeNumeric, self.get_lower_limit()).get_numerical_value()
+            < typing.cast(DegreeNumeric, value.get_lower_limit()).get_numerical_value()
+        ):
+            same = True
+        return same
+
+    def __ne__(self, value: typing.Self) -> bool:
+        return not (self == value)
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return f"{self.get_name_without_degree()} >= {self.degree}"

fuzzy_dl_owl2/fuzzydl/assertion/atomic_assertion.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
+
+
+class AtomicAssertion:
+    def __init__(self, c: Concept, degree: Degree) -> None:
+        self.c: Concept = c
+        self.degree: Degree = degree
+
+    def get_concept_name(self) -> str:
+        return str(self.c)
+
+    def get_degree(self) -> Degree:
+        return self.degree
+
+    def __str__(self) -> str:
+        return f"< {self.c} {self.degree} >"

fuzzy_dl_owl2/fuzzydl/concept/__init__.py

@@ -0,0 +1,13 @@
+from .concept import Concept
+from .choquet_integral import ChoquetIntegral
+from .concrete import *
+from .modified import *
+from .negated_nominal import NegatedNominal
+from .owa_concept import OwaConcept
+from .qowa_concept import QowaConcept
+from .sugeno_integral import SugenoIntegral
+from .quasi_sugeno_integral import QsugenoIntegral
+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

fuzzy_dl_owl2/fuzzydl/concept/all_some_concept.py

@@ -0,0 +1,85 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_role_concept_interface import (
+    HasRoleConceptInterface,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.truth_concept import TruthConcept
+from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+
+
+class AllSomeConcept(Concept, HasRoleConceptInterface):
+
+    def __init__(self, role: str, c: Concept, c_type: ConceptType) -> None:
+        Concept.__init__(self, c_type)
+        HasRoleConceptInterface.__init__(self, role, c)
+
+        assert c_type in (ConceptType.ALL, ConceptType.SOME)
+        self._name: str = self.compute_name()
+
+    @staticmethod
+    def new(c_type: ConceptType, role: str, concept: Concept) -> typing.Self:
+        if c_type == ConceptType.SOME:
+            if ConfigReader.OPTIMIZATIONS != 0 and concept.type == ConceptType.BOTTOM:
+                return TruthConcept.get_bottom()
+        else:
+            if ConfigReader.OPTIMIZATIONS != 0 and concept.type == ConceptType.TOP:
+                return TruthConcept.get_top()
+        return AllSomeConcept(role, concept, c_type)
+
+    @staticmethod
+    def all(role: str, concept: Concept) -> typing.Self:
+        return AllSomeConcept.new(ConceptType.ALL, role, concept)
+
+    @staticmethod
+    def some(role: str, concept: Concept) -> typing.Self:
+        return AllSomeConcept.new(ConceptType.SOME, role, concept)
+
+    def clone(self) -> typing.Self:
+        return AllSomeConcept.new(self.type, self.role, self.curr_concept)
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        return AllSomeConcept.new(self.type, self.role, self.curr_concept.replace(a, c))
+
+    def get_atoms(self) -> list[typing.Self]:
+        return self.curr_concept.get_atoms()
+
+    def is_complemented_atomic(self) -> bool:
+        return False
+
+    def compute_name(self) -> str:
+        if self.type == ConceptType.ALL:
+            return f"(all {self.role} {self.curr_concept})"
+        else:
+            return f"(some {self.role} {self.curr_concept})"
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        return self.curr_concept.compute_atomic_concepts()
+
+    def get_roles(self) -> set[str]:
+        return set([self.role]) | self.curr_concept.get_roles()
+
+    def __neg__(self) -> Concept:
+        return AllSomeConcept.new(
+            ConceptType.ALL if self.type == ConceptType.SOME else ConceptType.SOME,
+            self.role,
+            -self.curr_concept,
+        )
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+
+# class AllConcept(AllSomeConcept):
+#     def __call__(self, *args) -> typing.Self:
+#         return AllSomeConcept.all(args)
+
+
+# class SomeConcept(AllSomeConcept):
+#     def __call__(self, *args) -> typing.Self:
+#         return AllSomeConcept.some(args)
+
+
+All = AllSomeConcept.all
+Some = AllSomeConcept.some

fuzzy_dl_owl2/fuzzydl/concept/approximation_concept.py

@@ -0,0 +1,147 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_role_concept_interface import (
+    HasRoleConceptInterface,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+
+
+class ApproximationConcept(Concept, HasRoleConceptInterface):
+
+    INVERSE_APPROXIMATION: dict[ConceptType, ConceptType] = {
+        k: v
+        for k, v in zip(
+            [
+                ConceptType.LOWER_APPROX,
+                ConceptType.TIGHT_LOWER_APPROX,
+                ConceptType.LOOSE_LOWER_APPROX,
+                ConceptType.UPPER_APPROX,
+                ConceptType.TIGHT_UPPER_APPROX,
+                ConceptType.LOOSE_UPPER_APPROX,
+            ],
+            [
+                ConceptType.UPPER_APPROX,
+                ConceptType.TIGHT_UPPER_APPROX,
+                ConceptType.LOOSE_UPPER_APPROX,
+                ConceptType.LOWER_APPROX,
+                ConceptType.TIGHT_LOWER_APPROX,
+                ConceptType.LOOSE_LOWER_APPROX,
+            ],
+        )
+    }
+
+    def __init__(self, c_type: ConceptType, role: str, c: Concept) -> None:
+        Concept.__init__(self, c_type)
+        HasRoleConceptInterface.__init__(self, role, c)
+
+        assert c_type in (
+            ConceptType.LOWER_APPROX,
+            ConceptType.TIGHT_LOWER_APPROX,
+            ConceptType.LOOSE_LOWER_APPROX,
+            ConceptType.UPPER_APPROX,
+            ConceptType.TIGHT_UPPER_APPROX,
+            ConceptType.LOOSE_UPPER_APPROX,
+        )
+
+        self.name = self.compute_name()
+
+    @staticmethod
+    def lower_approx(role: str, c: Concept) -> Concept:
+        return ApproximationConcept(ConceptType.LOWER_APPROX, role, c)
+
+    @staticmethod
+    def loose_lower_approx(role: str, c: Concept) -> Concept:
+        return ApproximationConcept(ConceptType.LOOSE_LOWER_APPROX, role, c)
+
+    @staticmethod
+    def tight_lower_approx(role: str, c: Concept) -> Concept:
+        return ApproximationConcept(ConceptType.TIGHT_LOWER_APPROX, role, c)
+
+    @staticmethod
+    def upper_approx(role: str, c: Concept) -> Concept:
+        return ApproximationConcept(ConceptType.UPPER_APPROX, role, c)
+
+    @staticmethod
+    def loose_upper_approx(role: str, c: Concept) -> Concept:
+        return ApproximationConcept(ConceptType.LOOSE_UPPER_APPROX, role, c)
+
+    @staticmethod
+    def tight_upper_approx(role: str, c: Concept) -> Concept:
+        return ApproximationConcept(ConceptType.TIGHT_UPPER_APPROX, role, c)
+
+    def clone(self) -> typing.Self:
+        return ApproximationConcept(self.type, self.role, self.curr_concept)
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        if isinstance(c, ApproximationConcept):
+            c_type: ConceptType = c.type
+            if c_type == ConceptType.LOWER_APPROX:
+                return ApproximationConcept.lower_approx(
+                    self.role, self.curr_concept.replace(a, c)
+                )
+            elif c_type == ConceptType.LOOSE_LOWER_APPROX:
+                return ApproximationConcept.loose_lower_approx(
+                    self.role, self.curr_concept.replace(a, c)
+                )
+            elif c_type == ConceptType.TIGHT_LOWER_APPROX:
+                return ApproximationConcept.tight_lower_approx(
+                    self.role, self.curr_concept.replace(a, c)
+                )
+            elif c_type == ConceptType.UPPER_APPROX:
+                return ApproximationConcept.upper_approx(
+                    self.role, self.curr_concept.replace(a, c)
+                )
+            elif c_type == ConceptType.LOOSE_UPPER_APPROX:
+                return ApproximationConcept.loose_upper_approx(
+                    self.role, self.curr_concept.replace(a, c)
+                )
+            elif c_type == ConceptType.TIGHT_UPPER_APPROX:
+                return ApproximationConcept.tight_upper_approx(
+                    self.role, self.curr_concept.replace(a, c)
+                )
+
+    def compute_name(self) -> typing.Optional[str]:
+        if 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.LOOSE_LOWER_APPROX:
+            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})"
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        return self.curr_concept.compute_atomic_concepts()
+
+    def get_roles(self) -> set[str]:
+        return set([self.role]) | self.curr_concept.get_roles()
+
+    def __neg__(self) -> Concept:
+        return ApproximationConcept(
+            ApproximationConcept.INVERSE_APPROXIMATION[self.type],
+            self.role,
+            -self.curr_concept,
+        )
+
+    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))
+
+
+LowerApprox = ApproximationConcept.lower_approx
+LooseLowerApprox = ApproximationConcept.loose_lower_approx
+TightLowerApprox = ApproximationConcept.tight_lower_approx
+UpperApprox = ApproximationConcept.upper_approx
+LooseUpperApprox = ApproximationConcept.loose_upper_approx
+TightUpperApprox = ApproximationConcept.tight_upper_approx

fuzzy_dl_owl2/fuzzydl/concept/atomic_concept.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+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 AtomicConcept(Concept):
+    def __init__(self, name: str) -> None:
+        super().__init__(c_type=ConceptType.ATOMIC, name=name)
+
+    @staticmethod
+    def new_atomic_concept() -> typing.Self:
+        Concept.num_new_concepts += 1
+        return AtomicConcept(
+            f"NewConcept{Concept.SPECIAL_STRING}{Concept.num_new_concepts}"
+        )
+
+    def is_concrete(self) -> bool:
+        return False
+
+    def is_atomic(self) -> bool:
+        return True
+
+    def is_complemented_atomic(self) -> bool:
+        return False
+
+    def get_atomic_concepts(self) -> set[typing.Self]:
+        return self.compute_atomic_concepts()
+
+    def compute_name(self) -> str:
+        return self.name
+
+    def get_atoms(self) -> list[typing.Self]:
+        return [self]
+
+    def get_clauses(self, is_type: typing.Callable) -> set[typing.Self]:
+        return set([self])
+
+    def clone(self) -> typing.Self:
+        return AtomicConcept(self.name)
+
+    def compute_atomic_concepts(self) -> set[typing.Self]:
+        return [self]
+
+    def get_roles(self) -> set[str]:
+        return set()
+
+    def replace(self, a: typing.Self, c: typing.Self) -> typing.Optional[typing.Self]:
+        if c.type == ConceptType.ATOMIC:
+            if self == a:
+                return c
+            return self
+        Util.error(f"Error replacing in concept {self}")
+
+    def reduce_idempotency(self, is_type: typing.Callable) -> typing.Self:
+        return self
+
+    def __invert__(self) -> typing.Self:
+        return -self
+
+    def __neg__(self) -> typing.Self:
+        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 __rshift__(self, value: typing.Self) -> typing.Self:
+        # return ImpliesConcept([self, value], ConceptType.GOEDEL_IMPLIES)
+        pass
+
+    def __eq__(self, value: typing.Self) -> bool:
+        return isinstance(value, AtomicConcept) and str(self) == str(value)
+
+    def __ne__(self, value: typing.Self) -> bool:
+        return not (self == value)
+
+    def __hash__(self) -> int:
+        return hash(self.name)
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    # def __str__(self) -> str:
+    #     return self.compute_name()

fuzzy_dl_owl2/fuzzydl/concept/choquet_integral.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_weighted_concepts_interface import (
+    HasWeightedConceptsInterface,
+)
+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 ChoquetIntegral(Concept, HasWeightedConceptsInterface):
+    def __init__(self, weights: list[float], concepts: list[Concept]) -> None:
+        Concept.__init__(self, ConceptType.CHOQUET_INTEGRAL)
+        HasWeightedConceptsInterface.__init__(self, weights, concepts)
+
+        if weights is not None:
+            if len(weights) != len(concepts):
+                Util.error(
+                    "Error: The number of weights and the number of concepts should be the same"
+                )
+            self.name: str = str(self)
+
+    def clone(self) -> typing.Self:
+        return ChoquetIntegral(self.weights[:], [c for c in self.concepts])
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        concept_list = set()
+        for c in self.concepts:
+            concept_list.update(c.compute_atomic_concepts())
+        return concept_list
+
+    def get_roles(self) -> set[str]:
+        role_list = set()
+        for c in self.concepts:
+            role_list.update(c.get_roles())
+        return role_list
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        return -ChoquetIntegral(
+            self.weights, [ci.replace(a, c) for ci in self.concepts]
+        )
+
+    def compute_name(self) -> str:
+        str_weights: str = ""
+        if self.weights is not None:
+            str_weights = " ".join(list(str, self.weights))
+        str_concepts: str = " ".join(list(str, self.concepts))
+        name = f"(choquet ({str_weights}) ({str_concepts}))"
+        return name
+
+    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))