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

fuzzy_dl_owl2/fuzzydl/general_concept_inclusion.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
+from fuzzy_dl_owl2.fuzzydl.util.constants import LogicOperatorType
+
+
+class GeneralConceptInclusion:
+    def __init__(
+        self,
+        subsumer: Concept,
+        subsumed: Concept,
+        degree: Degree,
+        type_: LogicOperatorType,
+    ):
+        self.subsumer: Concept = subsumer
+        self.subsumed: Concept = subsumed
+        self.degree: Degree = degree
+        self.type: LogicOperatorType = type_
+
+    def clone(self) -> typing.Self:
+        return GeneralConceptInclusion(
+            self.subsumer, self.subsumed, self.degree, self.type
+        )
+
+    def get_subsumer(self) -> Concept:
+        return self.subsumer
+
+    def get_subsumed(self) -> Concept:
+        return self.subsumed
+
+    def get_type(self) -> LogicOperatorType:
+        return self.type
+
+    def get_degree(self) -> Degree:
+        return self.degree
+
+    def set_degree(self, deg: Degree) -> None:
+        self.degree = deg
+
+    def set_subsumer(self, new_concept: Concept) -> None:
+        self.subsumer = new_concept
+
+    def set_subsumed(self, new_concept: Concept) -> None:
+        self.subsumed = new_concept
+
+    def __eq__(self, other: typing.Self) -> bool:
+        return (
+            isinstance(other, GeneralConceptInclusion)
+            and self.subsumed == other.subsumed
+            and self.subsumer == other.subsumer
+            and self.degree == other.degree
+            and self.type == other.type
+        )
+
+    def __ne__(self, other: typing.Self) -> bool:
+        return not (self == other)
+
+    def __lt__(self, other: typing.Self) -> bool:
+        return isinstance(other, GeneralConceptInclusion) and hash(self) < hash(other)
+
+    def __le__(self, other: typing.Self) -> bool:
+        return not (self > other)
+
+    def __gt__(self, other: typing.Self) -> bool:
+        return isinstance(other, GeneralConceptInclusion) and hash(self) > hash(other)
+
+    def __ge__(self, other: typing.Self) -> bool:
+        return not (self < other)
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return (
+            f"{self.subsumed} =>_{self.type.name[0]} {self.subsumer} >= {self.degree}"
+        )

fuzzy_dl_owl2/fuzzydl/individual/__init__.py

@@ -0,0 +1,3 @@
+from .individual import Individual
+from .representative_individual import *
+from .created_individual import *

fuzzy_dl_owl2/fuzzydl/individual/created_individual.py

@@ -0,0 +1,219 @@
+from __future__ import annotations
+
+import copy
+import typing
+from collections import deque
+
+from sortedcontainers import SortedSet
+
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_number.triangular_fuzzy_number import (
+    TriangularFuzzyNumber,
+)
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.individual.representative_individual import (
+    RepresentativeIndividual,
+)
+from fuzzy_dl_owl2.fuzzydl.relation import Relation
+from fuzzy_dl_owl2.fuzzydl.util import constants
+from fuzzy_dl_owl2.fuzzydl.util.constants import (
+    CreatedIndividualBlockingType,
+    InequalityType,
+)
+from fuzzy_dl_owl2.fuzzydl.util.util import Util
+
+
+class CreatedIndividual(Individual):
+
+    @typing.overload
+    def __init__(
+        self,
+        name: str,
+        parent: typing.Optional[Individual] = None,
+        role_name: typing.Optional[str] = None,
+    ) -> None: ...
+
+    @typing.overload
+    def __init__(self, name: str) -> None: ...
+
+    def __init__(self, *args) -> None:
+        if len(args) not in [1, 3]:
+            raise NotImplementedError
+
+        assert isinstance(args[0], str)
+
+        if len(args) == 1:
+            self.__created_ind_init_2(*args)
+        else:
+            assert args[1] is None or isinstance(args[1], Individual)
+            assert args[2] is None or isinstance(args[2], str)
+            if len(args) == 3:
+                self.__created_ind_init_1(*args)
+
+    def __created_ind_init_1(
+        self,
+        name: str,
+        parent: typing.Optional[Individual] = None,
+        role_name: typing.Optional[str] = None,
+    ) -> None:
+        super().__init__(name)
+
+        self.representatives: list[RepresentativeIndividual] = list()
+
+        self.concept_list: set[int] = set()
+        self.directly_blocked: CreatedIndividualBlockingType = (
+            CreatedIndividualBlockingType.UNCHECKED
+        )
+        self.indirectly_blocked: CreatedIndividualBlockingType = (
+            CreatedIndividualBlockingType.UNCHECKED
+        )
+        self.not_self_roles: set[str] = set()
+        self.parent: typing.Optional[Individual] = parent
+        self.role_name: str = role_name
+        self.depth: int = (
+            typing.cast(CreatedIndividual, parent).depth + 1
+            if parent is not None and parent.is_blockable()
+            else 2
+        )
+
+        self.blocking_ancestor: typing.Optional[str] = None
+        self.blocking_ancestor_y: typing.Optional[str] = None
+        self.blocking_ancestor_y_prime: typing.Optional[str] = None
+        self._is_concrete: bool = False
+
+        if parent is not None:
+            Util.debug(
+                f"Created new individual {name}, ID = {self.get_integer_id()} with parent {parent}"
+            )
+
+    def __created_ind_init_2(self, name: str) -> None:
+        self.__created_ind_init_1(name, None, None)
+        Util.debug(f"Created new individual {name}, ID = {self.get_integer_id()}")
+
+    def clone(self) -> typing.Self:
+        ind: CreatedIndividual = CreatedIndividual(str(self), None, self.role_name)
+        self.clone_special_attributes(ind)
+        return ind
+
+    def clone_special_attributes(self, ind: typing.Self) -> None:
+        self.clone_attributes(ind)
+        ind.representatives = copy.deepcopy(self.representatives)
+        ind.blocking_ancestor = (
+            self.blocking_ancestor if self.blocking_ancestor is not None else None
+        )
+        ind.blocking_ancestor_y = (
+            self.blocking_ancestor_y if self.blocking_ancestor_y is not None else None
+        )
+        ind.blocking_ancestor_y_prime = (
+            self.blocking_ancestor_y_prime
+            if self.blocking_ancestor_y_prime is not None
+            else None
+        )
+        ind.concept_list = copy.deepcopy(self.concept_list)
+        ind.depth = self.depth
+        ind.directly_blocked = self.directly_blocked
+        ind.indirectly_blocked = copy.deepcopy(self.indirectly_blocked)
+        ind._is_concrete = self._is_concrete
+        if self.parent is not None:
+            ind.parent = self.parent.clone()
+        ind.role_name = self.role_name
+
+    def get_integer_id(self) -> int:
+        return int(self.name[1:])
+
+    def get_depth(self) -> int:
+        return self.depth
+
+    def get_parent(self) -> typing.Optional[Individual]:
+        return self.parent
+
+    def get_parent_name(self) -> str:
+        return self.parent.name if self.parent else ""
+
+    def get_role_name(self) -> str:
+        return self.role_name
+
+    def get_representative_if_exists(
+        self,
+        type: InequalityType,
+        f_name: str,
+        f: TriangularFuzzyNumber,
+    ) -> typing.Optional[typing.Self]:
+        for ind in self.representatives:
+            if (
+                ind.get_type() != type
+                or ind.get_feature_name() != f_name
+                or ind.get_fuzzy_number() != f
+            ):
+                continue
+            return ind.get_individual()
+        return None
+
+    def mark_indirectly_blocked(self) -> None:
+        Util.debug(
+            f"{constants.SEPARATOR}Mark subtree of {self.name} indirectly blocked"
+        )
+        queue: deque[CreatedIndividual] = deque()
+        queue.append(self)
+        while len(queue) > 0:
+            ind: CreatedIndividual = queue.popleft()
+            if len(ind.role_relations) == 0:
+                break
+            for role in ind.role_relations:
+                rels: list[Relation] = copy.deepcopy(ind.role_relations[role])
+                for rel in rels:
+                    Util.debug(
+                        f"{rel.get_subject_individual()} has role {rel.get_role_name()} with filler {rel.get_object_individual()}"
+                    )
+                    son: Individual = rel.get_object_individual()
+                    if son != ind.parent:
+                        if not son.is_blockable():
+                            continue
+                        son: CreatedIndividual = typing.cast(CreatedIndividual, son)
+                        Util.debug(
+                            f"Filler is not {self.name}'s parent, so mark {son} as INDIRECTLY BLOCKED"
+                        )
+                        son.indirectly_blocked = CreatedIndividualBlockingType.BLOCKED
+                        if rel.get_subject_individual() != rel.get_object_individual():
+                            queue.append(son)
+                    Util.debug("Filler is parent, so skip")
+        Util.debug(
+            f"{constants.SEPARATOR}END Mark INDIRECTLY BLOCKED subtree of {self.name}{constants.SEPARATOR}"
+        )
+
+    def individual_set_intersection_of(
+        self, set1: SortedSet[typing.Self], set2: SortedSet[typing.Self]
+    ) -> SortedSet[typing.Self]:
+        return set1.intersection(set2)
+
+    def set_concrete_individual(self) -> None:
+        self._is_concrete = True
+
+    def is_concrete(self) -> bool:
+        return self._is_concrete
+
+    def is_blockable(self) -> bool:
+        return len(self.nominal_list) == 0
+
+    def __eq__(self, value: typing.Self) -> bool:
+        return self.name == value.name
+
+    def __ne__(self, value: typing.Self) -> bool:
+        return not (self == value)
+
+    def __lt__(self, value: typing.Self) -> bool:
+        return self.get_integer_id() < value.get_integer_id()
+
+    def __ge__(self, value: typing.Self) -> bool:
+        return not (self < value)
+
+    def __le__(self, value: typing.Self) -> bool:
+        return self.get_integer_id() <= value.get_integer_id()
+
+    def __gt__(self, value: typing.Self) -> bool:
+        return not (self <= value)
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __str__(self) -> str:
+        return self.name

fuzzy_dl_owl2/fuzzydl/individual/individual.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import copy
+import typing
+from abc import abstractmethod
+
+from fuzzy_dl_owl2.fuzzydl.assertion.assertion import Assertion
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_number.triangular_fuzzy_number import (
+    TriangularFuzzyNumber,
+)
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.relation import Relation
+from fuzzy_dl_owl2.fuzzydl.restriction.restriction import Restriction
+from fuzzy_dl_owl2.fuzzydl.util.constants import RepresentativeIndividualType
+
+
+class Individual:
+    DEFAULT_NAME: str = "i"
+
+    def __init__(self, name: str) -> None:
+        self.name: str = name
+        self.concrete_role_restrictions: dict[str, list[Assertion]] = dict()
+        self.fillers_to_show: dict[str, set[str]] = dict()
+        self.list_of_concepts: set[Concept] = set()
+        self.nominal_list: set[str] = set()
+        self.not_self_roles: set[str] = list()
+        self.role_relations: dict[str, list[Relation]] = dict()
+        self.role_restrictions: dict[str, list[Restriction]] = dict()
+
+    def clone(self) -> typing.Self:
+        ind = Individual(self.name)
+        self.clone_attributes(ind)
+        return ind
+
+    def clone_attributes(self, ind: typing.Self) -> None:
+        ind.concrete_role_restrictions = {
+            k: [a for a in v] for k, v in self.concrete_role_restrictions.items()
+        }
+        ind.fillers_to_show = copy.deepcopy(self.fillers_to_show)
+        ind.list_of_concepts = set([c for c in self.list_of_concepts])
+        ind.nominal_list = copy.deepcopy(self.nominal_list)
+        ind.not_self_roles = copy.deepcopy(self.not_self_roles)
+        # ind.representatives = copy.deepcopy(self.representatives)
+        ind.role_restrictions = {
+            k: [r.clone() for r in v] for k, v in self.role_restrictions.items()
+        }
+        ind.role_relations = {
+            k: [r.clone() for r in v] for k, v in self.role_relations.items()
+        }
+
+    def set_name(self, name: str) -> None:
+        self.name = name
+
+    def add_concrete_restriction(self, f_name: str, ass: Assertion) -> None:
+        self.concrete_role_restrictions[f_name] = self.concrete_role_restrictions.get(
+            f_name, []
+        ) + [ass]
+
+    @abstractmethod
+    def get_representative_if_exists(
+        self,
+        type: RepresentativeIndividualType,
+        f_name: str,
+        f: TriangularFuzzyNumber,
+    ):
+        pass
+
+    def add_concept(self, c: Concept) -> None:
+        self.list_of_concepts.add(c)
+
+    def get_concepts(self) -> set[Concept]:
+        return self.list_of_concepts
+
+    def add_to_nominal_list(self, ind_name: str) -> None:
+        self.nominal_list.add(ind_name)
+
+    def get_nominal_list(self) -> set[str]:
+        return self.nominal_list
+
+    def is_blockable(self) -> bool:
+        return False
+
+    def set_label(self, ind_name: str) -> None:
+        raise InconsistentOntologyException(
+            f"Individuals cannot have names {self.name} and {ind_name}"
+        )
+
+    def prune(self) -> None:
+        to_prune: list[Individual] = []
+        for role in self.role_relations:
+            rels: list[Relation] = self.role_relations.get(role, [])
+            for r in rels:
+                obj: Individual = r.get_object_individual()
+                if obj.is_blockable():
+                    to_prune.append(obj)
+        self.role_relations = dict()
+        for i in to_prune:
+            i.prune()
+
+    def __eq__(self, value: typing.Self) -> bool:
+        return self.name == value.name
+
+    def __ne__(self, value: typing.Self) -> bool:
+        return not (self == value)
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return self.name

fuzzy_dl_owl2/fuzzydl/individual/representative_individual.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_number.triangular_fuzzy_number import (
+        TriangularFuzzyNumber,
+    )
+    from fuzzy_dl_owl2.fuzzydl.individual.created_individual import CreatedIndividual
+    from fuzzy_dl_owl2.fuzzydl.util.constants import RepresentativeIndividualType
+
+
+class RepresentativeIndividual:
+
+    def __init__(
+        self,
+        c_type: RepresentativeIndividualType,
+        f_name: str,
+        f: TriangularFuzzyNumber,
+        ind: CreatedIndividual,
+    ) -> None:
+        self.f_name: str = f_name
+        self.type: RepresentativeIndividualType = c_type
+        self.f: TriangularFuzzyNumber = f
+        self.ind: CreatedIndividual = ind
+
+    def get_type(self) -> RepresentativeIndividualType:
+        return self.type
+
+    def get_feature_name(self) -> str:
+        return self.f_name
+
+    def get_fuzzy_number(self) -> TriangularFuzzyNumber:
+        return self.f
+
+    def get_individual(self) -> CreatedIndividual:
+        return self.ind