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

fuzzy_dl_owl2/fuzzydl/milp/show_variables_helper.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import copy
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_concrete_concept import (
+    FuzzyConcreteConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+
+
+class ShowVariablesHelper:
+    def __init__(self) -> None:
+        self.abstract_fillers: dict[str, set[str]] = dict()
+        self.concepts: set[str] = set()
+        self.concrete_fillers: dict[str, set[str]] = dict()
+        self.global_abstract_fillers: set[str] = set()
+        self.global_concrete_fillers: set[str] = set()
+        self.individuals: set[str] = set()
+        self.labels_for_fillers: dict[str, list[FuzzyConcreteConcept]] = dict()
+        self.variables: dict[Variable, str] = dict()
+
+    def clone(self) -> typing.Self:
+        s = ShowVariablesHelper()
+        s.abstract_fillers = copy.deepcopy(self.abstract_fillers)
+        s.concepts = copy.deepcopy(self.concepts)
+        s.concrete_fillers = copy.deepcopy(self.concrete_fillers)
+        s.global_abstract_fillers = copy.deepcopy(self.global_abstract_fillers)
+        s.global_concrete_fillers = copy.deepcopy(self.global_concrete_fillers)
+        s.individuals = copy.deepcopy(self.individuals)
+        s.labels_for_fillers = {
+            k: [c for c in v] for k, v in self.labels_for_fillers.items()
+        }
+        s.variables = {k: v for k, v in self.variables.items()}
+        return s
+
+    def get_name(self, var: Variable) -> str:
+        return self.variables.get(var)
+
+    def show_variable(self, var: Variable) -> bool:
+        return var in self.variables
+
+    def add_individual_to_show(self, ind_name: str) -> None:
+        self.individuals.add(ind_name)
+
+    def show_individuals(self, ind_name: str) -> bool:
+        return ind_name in self.individuals
+
+    @typing.overload
+    def add_concrete_filler_to_show(self, f_name: str) -> None: ...
+
+    @typing.overload
+    def add_concrete_filler_to_show(self, f_name: str, ind_name: str) -> None: ...
+
+    @typing.overload
+    def add_concrete_filler_to_show(
+        self, f_name: str, ind_name: str, ar: list[FuzzyConcreteConcept]
+    ) -> None: ...
+
+    def add_concrete_filler_to_show(self, *args) -> None:
+        assert len(args) in [1, 2, 3]
+        assert isinstance(args[0], str)
+        if len(args) == 1:
+            self.__add_concrete_filler_to_show_1(*args)
+        elif len(args) == 2:
+            assert isinstance(args[1], str)
+            self.__add_concrete_filler_to_show_2(*args)
+        else:
+            assert isinstance(args[1], str)
+            assert isinstance(args[2], list) and all(
+                isinstance(a, FuzzyConcreteConcept) for a in args[2]
+            )
+            self.__add_concrete_filler_to_show_3(*args)
+
+    def __add_concrete_filler_to_show_1(self, f_name: str) -> None:
+        self.global_concrete_fillers.add(f_name)
+        if f_name in self.concrete_fillers:
+            del self.concrete_fillers[f_name]
+
+    def __add_concrete_filler_to_show_2(self, f_name: str, ind_name: str) -> None:
+        if f_name in self.global_concrete_fillers:
+            return
+        self.concrete_fillers[f_name] = self.concrete_fillers.get(f_name, set()) | set(
+            [ind_name]
+        )
+
+    def __add_concrete_filler_to_show_3(
+        self, f_name: str, ind_name: str, ar: list[FuzzyConcreteConcept]
+    ) -> None:
+        self.add_concrete_filler_to_show(f_name, ind_name)
+        name: str = f"{f_name}({ind_name})"
+        aux: list[FuzzyConcreteConcept] = self.get_labels(name)
+        if len(aux) > 0:
+            aux.extend(ar)
+            self.labels_for_fillers[name] = aux
+        else:
+            self.labels_for_fillers[name] = ar
+
+    def get_labels(self, var_name: str) -> list[FuzzyConcreteConcept]:
+        return self.labels_for_fillers.get(var_name, [])
+
+    @typing.overload
+    def add_abstract_filler_to_show(self, role_name: str) -> None: ...
+
+    @typing.overload
+    def add_abstract_filler_to_show(self, role_name: str, ind_name: str) -> None: ...
+
+    def add_abstract_filler_to_show(self, *args) -> None:
+        assert len(args) in [1, 2]
+        assert isinstance(args[0], str)
+        if len(args) == 1:
+            self.__add_abstract_filler_to_show_1(*args)
+        else:
+            assert isinstance(args[1], str)
+            self.__add_abstract_filler_to_show_2(*args)
+
+    def __add_abstract_filler_to_show_1(self, role_name: str) -> None:
+        self.global_abstract_fillers.add(role_name)
+        if role_name in self.abstract_fillers:
+            del self.abstract_fillers[role_name]
+
+    def __add_abstract_filler_to_show_2(self, role_name: str, ind_name: str) -> None:
+        if role_name in self.global_abstract_fillers:
+            return
+        self.abstract_fillers[role_name] = self.abstract_fillers.get(
+            role_name, set()
+        ) | set([ind_name])
+
+    def show_concrete_fillers(self, f_name: str, ind_name: str) -> bool:
+        if f_name not in self.global_concrete_fillers:
+            hs = self.concrete_fillers.get(f_name)
+            return hs is not None and ind_name in hs
+        return True
+
+    def show_abstract_role_fillers(self, role_name: str, ind_name: str) -> bool:
+        if role_name not in self.global_abstract_fillers:
+            hs = self.abstract_fillers.get(role_name)
+            return hs is not None and ind_name in hs
+        return True
+
+    def add_concept_to_show(self, conc_name: str) -> None:
+        self.concepts.add(conc_name)
+
+    def show_concepts(self, concept_name: str) -> bool:
+        return concept_name in self.concepts
+
+    def add_variable(self, var: Variable, name_to_show: str) -> None:
+        self.variables[var] = name_to_show
+
+    def get_variables(self) -> list[Variable]:
+        return list(self.variables.keys())

fuzzy_dl_owl2/fuzzydl/milp/solution.py

@@ -0,0 +1,45 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.util import constants
+
+
+class Solution:
+    CONSISTENT_KB: bool = True
+    INCONSISTENT_KB: bool = False
+
+    @typing.overload
+    def __init__(self, consistent: bool) -> None: ...
+
+    @typing.overload
+    def __init__(self, sol: float) -> None: ...
+
+    def __init__(self, *args) -> None:
+        assert len(args) == 1
+        if isinstance(args[0], bool):
+            self.__solution_init_1(*args)
+        elif isinstance(args[0], constants.NUMBER):
+            self.__solution_init_2(*args)
+        else:
+            raise ValueError
+
+    def __solution_init_1(self, consistent: bool) -> None:
+        self.sol: typing.Union[bool, float] = 0.0
+        self.consistent: bool = consistent
+
+    def __solution_init_2(self, sol: float) -> None:
+        self.sol: typing.Union[bool, float] = sol
+        self.consistent: bool = True
+
+    def is_consistent_kb(self) -> bool:
+        return self.consistent
+
+    def get_solution(self) -> typing.Union[bool, float]:
+        return self.sol
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        if self.consistent:
+            return str(self.sol)
+        return "Inconsistent KB"

fuzzy_dl_owl2/fuzzydl/milp/term.py

@@ -0,0 +1,76 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+from fuzzy_dl_owl2.fuzzydl.util import constants
+
+
+class Term:
+
+    @typing.overload
+    def __init__(self, coeff: float, var: Variable) -> None: ...
+
+    @typing.overload
+    def __init__(self, var: Variable) -> None: ...
+
+    def __init__(self, *args) -> None:
+        assert len(args) in [1, 2]
+        if len(args) == 1:
+            assert isinstance(args[0], Variable)
+            self.__term_init_2(*args)
+        else:
+            assert isinstance(args[0], constants.NUMBER)
+            assert isinstance(args[1], Variable)
+            self.__term_init_1(*args)
+
+    def __term_init_1(self, coeff: typing.Union[int, float], var: Variable) -> None:
+        self.var: Variable = var
+        self.coeff: float = coeff
+
+    def __term_init_2(self, var: Variable) -> None:
+        self.__term_init_1(1.0, var)
+
+    def clone(self) -> typing.Self:
+        return Term(self.coeff, self.var)
+
+    def get_var(self) -> Variable:
+        return self.var
+
+    def get_coeff(self) -> float:
+        return self.coeff
+
+    def clone(self) -> typing.Self:
+        return Term(self.coeff, self.var)
+
+    def __neg__(self) -> typing.Self:
+        return Term(-self.coeff, self.var)
+
+    def __add__(self, term: typing.Self) -> typing.Self:
+        if self.var != term.var:
+            raise ValueError("Cannot add terms with different variables")
+        return Term(self.coeff + term.coeff, self.var)
+
+    def __sub__(self, term: typing.Self) -> typing.Self:
+        return self + (-term)
+
+    def __mul__(self, scalar: float) -> typing.Self:
+        return Term(self.coeff * scalar, self.var)
+
+    def __rmul__(self, scalar: float) -> typing.Self:
+        return self * scalar
+
+    def __truediv__(self, scalar: float) -> typing.Self:
+        return self * (1 / scalar)
+
+    def __eq__(self, term: typing.Self) -> bool:
+        if not isinstance(term, Term):
+            return False
+        return self.var == term.var
+
+    def __ne__(self, term: typing.Self) -> bool:
+        return not (self == term)
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return f"{self.coeff} * {self.var}"

fuzzy_dl_owl2/fuzzydl/milp/variable.py

@@ -0,0 +1,89 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.util.constants import VariableType
+
+
+class Variable:
+    VARIABLE_NAME: str = "y"
+    VARIABLE_NUMBER: int = 0
+
+    def __init__(self, name: str, v_type: VariableType) -> None:
+        self.lower_bound: float = 0.0
+        self.upper_bound: float = 0.0
+        self.name: str = name
+        self.type: VariableType = None
+        self.datatype_filler: bool = False
+        self.set_type(v_type)
+
+    @staticmethod
+    def get_binary_variable(name: str) -> typing.Self:
+        return Variable(name, VariableType.BINARY)
+
+    @staticmethod
+    def get_continuous_variable(name: str) -> typing.Self:
+        return Variable(name, VariableType.CONTINUOUS)
+
+    @staticmethod
+    def get_semi_continuous_variable(name: str) -> typing.Self:
+        return Variable(name, VariableType.SEMI_CONTINUOUS)
+
+    @staticmethod
+    def get_integer_variable(name: str) -> typing.Self:
+        return Variable(name, VariableType.INTEGER)
+
+    def get_lower_bound(self) -> float:
+        return self.lower_bound
+
+    def get_type(self) -> VariableType:
+        return self.type
+
+    def get_datatype_filler_type(self) -> bool:
+        return self.datatype_filler
+
+    def get_upper_bound(self) -> float:
+        return self.upper_bound
+
+    def set_binary_variable(self) -> None:
+        self.set_type(VariableType.BINARY)
+
+    def set_datatype_filler_variable(self) -> None:
+        self.datatype_filler = True
+
+    def set_name(self, name: str) -> None:
+        self.name = name
+
+    def set_type(self, v_type: VariableType) -> None:
+        if v_type in (VariableType.BINARY, VariableType.SEMI_CONTINUOUS):
+            self.lower_bound = 0.0
+            self.upper_bound = 1.0
+        else:
+            assert v_type in (VariableType.CONTINUOUS, VariableType.INTEGER)
+            self.lower_bound = float("-inf")
+            self.upper_bound = float("inf")
+        self.type = v_type
+
+    @staticmethod
+    def get_new_variable(v_type: VariableType) -> typing.Self:
+        Variable.VARIABLE_NUMBER += 1
+        return Variable(f"{Variable.VARIABLE_NAME}{Variable.VARIABLE_NUMBER}", v_type)
+
+    def clone(self) -> typing.Self:
+        return Variable(self.name, self.type)
+
+    def __eq__(self, value: typing.Self) -> bool:
+        return str(self) == str(value)
+
+    def __ne__(self, value: object) -> bool:
+        return not (self == value)
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return self.name
+
+
+BinaryVar = Variable.get_binary_variable
+IntegerVar = Variable.get_integer_variable
+UpVar = Variable.get_semi_continuous_variable
+FreeVar = Variable.get_continuous_variable

fuzzy_dl_owl2/fuzzydl/modifier/__init__.py

@@ -0,0 +1,3 @@
+from .modifier import Modifier
+from .linear_modifier import LinearModifier
+from .triangular_modifier import TriangularModifier

fuzzy_dl_owl2/fuzzydl/modifier/linear_modifier.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.modified.linearly_modified_concept import (
+    LinearlyModifiedConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.modifier.modifier import Modifier
+
+
+class LinearModifier(Modifier):
+
+    def __init__(self, name: str, c: float) -> None:
+        super().__init__(name)
+        self._c: float = c
+        self._a: float = c / (c + 1.0)
+        self._b: float = 1.0 / (c + 1.0)
+
+    @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
+
+    @property
+    def c(self) -> float:
+        return self._c
+
+    @c.setter
+    def c(self, value: float) -> None:
+        self._c = value
+
+    def clone(self) -> typing.Self:
+        return LinearModifier(self.name, self.c)
+
+    def modify(self, concept: Concept) -> LinearlyModifiedConcept:
+        return LinearlyModifiedConcept(concept, self)
+
+    def compute_name(self) -> str:
+        return f"linear-modifier({self.c})"
+
+    def get_membership_degree(self, value: float) -> float:
+        if value <= 0.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 __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))
+
+    # def __str__(self) -> str:
+    #     return self.compute_name()

fuzzy_dl_owl2/fuzzydl/modifier/modifier.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import typing
+from abc import ABC, abstractmethod
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+
+
+class Modifier(ABC):
+
+    def __init__(self, name: str) -> None:
+        self.name: str = name
+
+    def set_name(self, name: str) -> None:
+        self.name = name
+
+    @abstractmethod
+    def compute_name(self) -> str:
+        pass
+
+    @abstractmethod
+    def clone(self) -> typing.Self:
+        pass
+
+    @abstractmethod
+    def modify(self, concept: Concept) -> Concept:
+        pass
+
+    @abstractmethod
+    def get_membership_degree(self, value: float) -> float:
+        pass
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        if self.name is None:
+            self.name = self.compute_name()
+        return self.name

fuzzy_dl_owl2/fuzzydl/modifier/triangular_modifier.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.modified.triangularly_modified_concept import (
+    TriangularlyModifiedConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.modifier.modifier import Modifier
+from fuzzy_dl_owl2.fuzzydl.util.util import Util
+
+
+class TriangularModifier(Modifier):
+    def __init__(self, name: str, a: float, b: float, c: float) -> None:
+        super().__init__(name)
+        if a > b or b > c:
+            Util.error(f"Error: Triangular functions require {a} <= {b} <= {c}")
+        self._a = a
+        self._b = b
+        self._c = c
+
+    @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
+
+    @property
+    def c(self) -> float:
+        return self._c
+
+    @c.setter
+    def c(self, value: float) -> None:
+        self._c = value
+
+    def clone(self) -> typing.Self:
+        return TriangularModifier(self.name, self.c)
+
+    def compute_name(self) -> str:
+        return f"triangular-modifier({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 modify(self, concept: Concept) -> Concept:
+        return TriangularlyModifiedConcept(concept, self)
+
+    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))
+
+    # def __str__(self) -> str:
+    #     return self.get_name()