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

fuzzy_dl_owl2/fuzzydl/concept/weighted_min_concept.py

@@ -0,0 +1,57 @@
+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 WeightedMinConcept(Concept, HasWeightedConceptsInterface):
+    def __init__(self, weights: list[float], concepts: list[Concept]) -> None:
+        Concept.__init__(self, ConceptType.W_MIN)
+        HasWeightedConceptsInterface.__init__(self, weights, concepts)
+
+        if len(weights) != len(concepts):
+            Util.error("Error: The number of weights and concepts should be the same")
+        if 1.0 not in weights:
+            Util.error("Error: Some weights must be 1.0")
+
+        self.name = self.compute_name()
+
+    def clone(self) -> typing.Self:
+        return WeightedMinConcept(self.weights[:], [c for c in self.concepts])
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        concept_list: set[Concept] = 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[str] = set()
+        for c in self.concepts:
+            role_list.update(c.get_roles())
+        return role_list
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        return -WeightedMinConcept(
+            self.weights, [ci.replace(a, c) for ci in self.concepts]
+        )
+
+    def compute_name(self) -> str:
+        return f"(w-min {' '.join([f'({concept} {weight})' for concept, weight in zip(self.concepts, self.weights)])})"
+
+    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/weighted_sum_concept.py

@@ -0,0 +1,62 @@
+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 WeightedSumConcept(Concept, HasWeightedConceptsInterface):
+
+    def __init__(self, weights: list[float], concepts: list[Concept]) -> None:
+        Concept.__init__(self, ConceptType.W_SUM)
+        HasWeightedConceptsInterface.__init__(self, weights, concepts)
+
+        if len(weights) != len(concepts):
+            Util.error(
+                "Error: The number of weights and the number of concepts should be the same."
+            )
+        if sum(weights) > 1.0:
+            Util.error(
+                "Error: The sum of the weights of the weighted sum concept cannot be greater than 1.0."
+            )
+
+        self.name = self.compute_name()
+
+    def clone(self) -> typing.Self:
+        return WeightedSumConcept(self.weights[:], [c for c in self.concepts])
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        concept_list: set[Concept] = 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[str] = set()
+        for c in self.concepts:
+            role_list.update(c.get_roles())
+        return role_list
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        return -WeightedSumConcept(
+            self.weights, [ci.replace(a, c) for ci in self.concepts]
+        )
+
+    def compute_name(self) -> str:
+        return f"(w-sum {' '.join([f'({weight} {concept})' for concept, weight in zip(self.concepts, self.weights)])})"
+
+    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/weighted_sum_zero_concept.py

@@ -0,0 +1,62 @@
+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 WeightedSumZeroConcept(Concept, HasWeightedConceptsInterface):
+
+    def __init__(self, weights: list[float], concepts: list[Concept]) -> None:
+        Concept.__init__(self, ConceptType.W_SUM_ZERO)
+        HasWeightedConceptsInterface.__init__(self, weights, concepts)
+
+        if len(weights) != len(concepts):
+            Util.error(
+                "Error: The number of weights and the number of concepts should be the same"
+            )
+        if sum(weights) > 1.0:
+            Util.error(
+                "Error: The sum of the weights of the weighted sum concept cannot be greater than 1.0."
+            )
+
+        self.name = self.compute_name()
+
+    def clone(self) -> typing.Self:
+        return WeightedSumZeroConcept(self.weights[:], [c for c in self.concepts])
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        concept_list: set[Concept] = 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[str] = set()
+        for c in self.concepts:
+            role_list.update(c.get_roles())
+        return role_list
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        return -WeightedSumZeroConcept(
+            self.weights, [ci.replace(a, c) for ci in self.concepts]
+        )
+
+    def compute_name(self) -> str:
+        return f"(w-sum-zero {' '.join([f'({weight} {concept})' for concept, weight in zip(self.concepts, self.weights)])})"
+
+    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_equivalence.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+
+
+class ConceptEquivalence:
+    def __init__(self, c1: Concept, c2: Concept) -> None:
+        self.c1: Concept = c1
+        self.c2: Concept = c2
+
+    def clone(self) -> typing.Self:
+        return ConceptEquivalence(self.c1, self.c2)
+
+    def get_c1(self) -> Concept:
+        return self.c1
+
+    def get_c2(self) -> Concept:
+        return self.c2

fuzzy_dl_owl2/fuzzydl/concrete_feature.py

@@ -0,0 +1,94 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConcreteFeatureType
+
+
+class ConcreteFeature:
+
+    @typing.overload
+    def __init__(self, name: str) -> None: ...
+
+    @typing.overload
+    def __init__(self, name: str, is_boolean: bool) -> None: ...
+
+    @typing.overload
+    def __init__(self, name: str, k1: int, k2: int) -> None: ...
+
+    @typing.overload
+    def __init__(self, name: str, k1: float, k2: float) -> None: ...
+
+    def __init__(self, *args) -> None:
+        assert len(args) in [1, 2, 3]
+
+        assert isinstance(args[0], str)
+        if len(args) == 1:
+            self.__concrete_feature_init_1(*args)
+        elif len(args) == 2:
+            assert isinstance(args[1], bool)
+            self.__concrete_feature_init_2(*args)
+        elif len(args) == 3:
+            if isinstance(args[1], int) and isinstance(args[2], int):
+                self.__concrete_feature_init_3(*args)
+            elif isinstance(args[1], float) and isinstance(args[2], float):
+                self.__concrete_feature_init_4(*args)
+            else:
+                raise ValueError
+        else:
+            raise ValueError
+
+    def __concrete_feature_init_1(self, name: str) -> None:
+        self.name: str = name
+        self.k1: typing.Optional[typing.Union[float, int]] = None
+        self.k2: typing.Optional[typing.Union[float, int]] = None
+        self.type: ConcreteFeatureType = ConcreteFeatureType.STRING
+
+    def __concrete_feature_init_2(self, name: str, is_boolean: bool) -> None:
+        self.__concrete_feature_init_1(name)
+        if is_boolean:
+            self.type: ConcreteFeatureType = ConcreteFeatureType.BOOLEAN
+
+    def __concrete_feature_init_3(self, name: str, k1: int, k2: int) -> None:
+        self.__concrete_feature_init_1(name)
+        self.k1: typing.Optional[typing.Union[float, int]] = k1
+        self.k2: typing.Optional[typing.Union[float, int]] = k2
+        self.type: ConcreteFeatureType = ConcreteFeatureType.INTEGER
+
+    def __concrete_feature_init_4(self, name: str, k1: float, k2: float) -> None:
+        self.__concrete_feature_init_1(name)
+        self.k1: typing.Optional[typing.Union[float, int]] = k1
+        self.k2: typing.Optional[typing.Union[float, int]] = k2
+        self.type: ConcreteFeatureType = ConcreteFeatureType.REAL
+
+    def clone(self) -> typing.Self:
+        if self.type == ConcreteFeatureType.BOOLEAN:
+            return ConcreteFeature(self.name, is_boolean=True)
+        elif self.type == ConcreteFeatureType.STRING:
+            return ConcreteFeature(self.name)
+
+        return ConcreteFeature(self.name, self.k1, self.k2)
+
+    def get_type(self) -> ConcreteFeatureType:
+        return self.type
+
+    def set_type(self, new_type: ConcreteFeatureType) -> None:
+        self.type = new_type
+
+    def get_k1(self) -> typing.Optional[typing.Union[float, int]]:
+        return self.k1
+
+    def get_k2(self) -> typing.Optional[typing.Union[float, int]]:
+        return self.k2
+
+    def set_range(
+        self,
+        k1: typing.Optional[typing.Union[float, int]],
+        k2: typing.Optional[typing.Union[float, int]],
+    ) -> None:
+        self.k1 = k1
+        self.k2 = k2
+
+    def get_name(self) -> str:
+        return self.name
+
+    def __str__(self) -> str:
+        return self.get_name()

fuzzy_dl_owl2/fuzzydl/degree/__init__.py

@@ -0,0 +1,4 @@
+from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
+from fuzzy_dl_owl2.fuzzydl.degree.degree_expression import DegreeExpression
+from fuzzy_dl_owl2.fuzzydl.degree.degree_numeric import DegreeNumeric
+from fuzzy_dl_owl2.fuzzydl.degree.degree_variable import DegreeVariable

fuzzy_dl_owl2/fuzzydl/degree/degree.py

@@ -0,0 +1,79 @@
+import typing
+from abc import ABC, abstractmethod
+
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.inequation import Inequation
+from fuzzy_dl_owl2.fuzzydl.util.constants import InequalityType
+
+
+class Degree(ABC):
+
+    @staticmethod
+    @abstractmethod
+    def get_degree(value) -> typing.Self:
+        raise NotImplementedError
+
+    # @typing.overload
+    # @staticmethod
+    # def get_degree(value: float) -> typing.Self:
+    #     return DegreeNumeric(value)
+
+    # @typing.overload
+    # @staticmethod
+    # def get_degree(value: Variable) -> typing.Self:
+    #     return DegreeVariable(value)
+
+    # @typing.overload
+    # @staticmethod
+    # def get_degree(value: Expression) -> typing.Self:
+    #     return DegreeExpression(value)
+
+    @abstractmethod
+    def clone(self) -> typing.Self:
+        pass
+
+    @abstractmethod
+    def is_numeric(self) -> bool:
+        pass
+
+    @abstractmethod
+    def create_inequality_with_degree_rhs(
+        self,
+        expression: Expression,
+        inequation_type: InequalityType,
+    ) -> Inequation:
+        pass
+
+    @abstractmethod
+    def add_to_expression(self, expression: Expression) -> Expression:
+        pass
+
+    @abstractmethod
+    def subtract_from_expression(self, expression: Expression) -> Expression:
+        pass
+
+    @abstractmethod
+    def multiply_constant(self, double: float) -> Expression:
+        pass
+
+    @abstractmethod
+    def __str__(self) -> str:
+        pass
+
+    @abstractmethod
+    def __eq__(self, degree: typing.Self) -> bool:
+        pass
+
+    def __ne__(self, value: typing.Self) -> bool:
+        return not (self == value)
+
+    @abstractmethod
+    def is_number_not_one(self) -> bool:
+        pass
+
+    @abstractmethod
+    def is_number_zero(self) -> bool:
+        pass
+
+    def __repr__(self) -> str:
+        return str(self)

fuzzy_dl_owl2/fuzzydl/degree/degree_expression.py

@@ -0,0 +1,57 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.inequation import Inequation
+from fuzzy_dl_owl2.fuzzydl.util.constants import InequalityType
+
+
+class DegreeExpression(Degree):
+    def __init__(self, expr: Expression) -> None:
+        self.expr: Expression = expr
+
+    def get_expression(self) -> Expression:
+        return self.expr
+
+    @staticmethod
+    def get_degree(value: Expression) -> typing.Self:
+        return DegreeExpression(value)
+
+    def clone(self) -> typing.Self:
+        return DegreeExpression.get_degree(self.expr)
+
+    def create_inequality_with_degree_rhs(
+        self,
+        expr: Expression,
+        inequality_type: InequalityType,
+    ) -> Inequation:
+        return Inequation(
+            expr - self.expr,
+            inequality_type,
+        )
+
+    def is_numeric(self) -> bool:
+        return False
+
+    def add_to_expression(self, expr: Expression) -> Expression:
+        return expr + self.expr
+
+    def subtract_from_expression(self, expr: Expression) -> Expression:
+        return expr - self.expr
+
+    def multiply_constant(self, constant: float) -> Expression:
+        return self.expr * constant
+
+    def is_number_not_one(self) -> bool:
+        return False
+
+    def is_number_zero(self) -> bool:
+        return False
+
+    def __eq__(self, d: Degree) -> bool:
+        if isinstance(d, DegreeExpression):
+            return d == self.get_expression()
+        return False
+
+    def __str__(self) -> str:
+        return f"Degree({self.expr})"

fuzzy_dl_owl2/fuzzydl/degree/degree_numeric.py

@@ -0,0 +1,57 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.inequation import Inequation
+from fuzzy_dl_owl2.fuzzydl.util.constants import InequalityType
+
+
+class DegreeNumeric(Degree):
+
+    def __init__(self, numeric: float) -> None:
+        self.value: float = float(numeric)
+
+    @staticmethod
+    def get_one() -> typing.Self:
+        return DegreeNumeric(1.0)
+
+    @staticmethod
+    def get_degree(value: float) -> typing.Self:
+        return DegreeNumeric(value)
+
+    def clone(self) -> typing.Self:
+        return DegreeNumeric.get_degree(self.value)
+
+    def get_numerical_value(self) -> float:
+        return self.value
+
+    def create_inequality_with_degree_rhs(
+        self, expr: Expression, inequation_type: InequalityType
+    ) -> Inequation:
+        return Inequation(expr - 1.0 * self.value, inequation_type)
+
+    def is_numeric(self) -> bool:
+        return True
+
+    def add_to_expression(self, expr: Expression) -> Expression:
+        return expr + self.value
+
+    def subtract_from_expression(self, expr: Expression) -> Expression:
+        return expr - self.value
+
+    def multiply_constant(self, constant: float) -> Expression:
+        return Expression(self.value * constant)
+
+    def is_number_not_one(self) -> bool:
+        return self.value != 1.0
+
+    def is_number_zero(self) -> bool:
+        return self.value == 0.0
+
+    def __eq__(self, d: Degree) -> bool:
+        if isinstance(d, DegreeNumeric):
+            return self.value == d.get_numerical_value()
+        return False
+
+    def __str__(self) -> str:
+        return f"Degree({self.value})"

fuzzy_dl_owl2/fuzzydl/degree/degree_variable.py

@@ -0,0 +1,54 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.inequation import Inequation
+from fuzzy_dl_owl2.fuzzydl.milp.term import Term
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+from fuzzy_dl_owl2.fuzzydl.util.constants import InequalityType
+
+
+class DegreeVariable(Degree):
+    def __init__(self, variable: Variable) -> None:
+        self.variable: Variable = variable
+
+    @staticmethod
+    def get_degree(value: Variable) -> typing.Self:
+        return DegreeVariable(value)
+
+    def get_variable(self) -> Variable:
+        return self.variable
+
+    def clone(self) -> typing.Self:
+        return DegreeVariable.get_degree(self.variable)
+
+    def create_inequality_with_degree_rhs(
+        self, expr: Expression, inequality_type: InequalityType
+    ) -> Inequation:
+        return Inequation(expr + Term(-1.0, self.variable), inequality_type)
+
+    def is_numeric(self) -> bool:
+        return False
+
+    def add_to_expression(self, expr: Expression) -> Expression:
+        return expr + Term(1.0, self.variable)
+
+    def subtract_from_expression(self, expr: Expression) -> Expression:
+        return expr + Term(-1.0, self.variable)
+
+    def multiply_constant(self, constant: float) -> Expression:
+        return Expression(Term(constant, self.variable))
+
+    def is_number_not_one(self) -> bool:
+        return False
+
+    def is_number_zero(self) -> bool:
+        return False
+
+    def __eq__(self, degree: Degree) -> bool:
+        if isinstance(degree, DegreeVariable):
+            return degree.get_variable() == self.get_variable()
+        return False
+
+    def __str__(self) -> str:
+        return f"Degree({self.variable})"

fuzzy_dl_owl2/fuzzydl/domain_axiom.py

@@ -0,0 +1,8 @@
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+
+
+class DomainAxiom:
+
+    def __init__(self, role: str, concept: Concept) -> None:
+        self.role: str = role
+        self.concept: Concept = concept

fuzzy_dl_owl2/fuzzydl/exception/__init__.py

@@ -0,0 +1,2 @@
+from .fuzzy_ontology_exception import FuzzyOntologyException
+from .inconsistent_ontology_exception import InconsistentOntologyException

fuzzy_dl_owl2/fuzzydl/exception/fuzzy_ontology_exception.py

@@ -0,0 +1,4 @@
+class FuzzyOntologyException(Exception):
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)

fuzzy_dl_owl2/fuzzydl/exception/inconsistent_ontology_exception.py

@@ -0,0 +1,4 @@
+class InconsistentOntologyException(Exception):
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)