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

fuzzy_dl_owl2/fuzzydl/query/min/min_subsumes_query.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.implies_concept import ImpliesConcept
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.degree.degree_expression import DegreeExpression
+from fuzzy_dl_owl2.fuzzydl.exception.inconsistent_ontology_exception import (
+    InconsistentOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
+from fuzzy_dl_owl2.fuzzydl.milp.term import Term
+from fuzzy_dl_owl2.fuzzydl.milp.variable import Variable
+from fuzzy_dl_owl2.fuzzydl.query.subsumption_query import SubsumptionQuery
+from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
+from fuzzy_dl_owl2.fuzzydl.util.constants import LogicOperatorType, VariableType
+
+
+class MinSubsumesQuery(SubsumptionQuery):
+
+    def __init__(self, c1: Concept, c2: Concept, type_: LogicOperatorType) -> None:
+        super().__init__(c1, c2, type_)
+
+    def preprocess(self, kb: KnowledgeBase) -> None:
+        ind: Individual = kb.get_new_individual()
+
+        if self.type == LogicOperatorType.LUKASIEWICZ:
+            conc: Concept = OperatorConcept.lukasiewicz_or(-self.c2, self.c1)
+        elif self.type == LogicOperatorType.GOEDEL:
+            conc: Concept = ImpliesConcept.goedel_implies(self.c2, self.c1)
+        elif self.type == LogicOperatorType.KLEENE_DIENES:
+            conc: Concept = ImpliesConcept.zadeh_implies(self.c2, self.c1)
+        else:  # LogicOperatorType.ZADEH
+            conc: Concept = OperatorConcept.goedel_or(-self.c2, self.c1)
+
+        q: Variable = kb.milp.get_new_variable(VariableType.SEMI_CONTINUOUS)
+        kb.old_01_variables += 1
+        self.obj_expr: Expression = Expression(Term(1.0, q))
+
+        kb.add_assertion(
+            ind,
+            -conc,
+            DegreeExpression.get_degree(Expression(1.0, Term(-1.0, q))),
+        )
+        kb.solve_assertions()
+
+    def solve(self, kb: KnowledgeBase) -> Solution:
+        try:
+            self.set_initial_time()
+            if ConfigReader.OPTIMIZATIONS == 0 or kb.has_nominals_in_tbox():
+                cloned: KnowledgeBase = kb.clone()
+                cloned.solve_abox()
+            else:
+                cloned: KnowledgeBase = kb.clone_without_abox()
+            self.preprocess(cloned)
+            sol: Solution = cloned.optimize(self.obj_expr)
+            self.set_total_time()
+            return sol
+        except InconsistentOntologyException:
+            return Solution(False)
+
+    def __str__(self) -> str:
+        return f"{self.c1} subsumes {self.c2} ? >= "

fuzzy_dl_owl2/fuzzydl/query/query.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import time
+from abc import ABC, abstractmethod
+
+from fuzzy_dl_owl2.fuzzydl.knowledge_base import KnowledgeBase
+from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
+
+
+class Query(ABC):
+    def __init__(self) -> None:
+        self.initial_time: int = 0
+        self.total_time: int = 0
+
+    def set_initial_time(self) -> None:
+        self.initial_time = time.perf_counter_ns()
+
+    def set_total_time(self) -> None:
+        end_time: int = time.perf_counter_ns()
+        self.total_time = end_time - self.initial_time
+
+    def get_total_time(self) -> float:
+        return self.total_time / 1e9
+
+    @abstractmethod
+    def preprocess(self, knowledge_base: KnowledgeBase) -> None:
+        """Preprocess the query with given knowledge base"""
+        pass
+
+    @abstractmethod
+    def solve(self, knowledge_base: KnowledgeBase) -> Solution:
+        """Solve the query using given knowledge base"""
+        pass
+
+    @abstractmethod
+    def __str__(self) -> str:
+        """String representation of the query"""
+        pass

fuzzy_dl_owl2/fuzzydl/query/related_query.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.query.query import Query
+
+
+class RelatedQuery(Query):
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.role: str = None
+        self.ind1: Individual = None
+        self.ind2: Individual = None
+        self.obj_expr: Expression = None

fuzzy_dl_owl2/fuzzydl/query/satisfiable_query.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.query.query import Query
+from fuzzy_dl_owl2.fuzzydl.util.util import Util
+
+
+class SatisfiableQuery(Query):
+
+    @typing.overload
+    def __init__(self, c: Concept, a: Individual) -> None: ...
+
+    @typing.overload
+    def __init__(self, c: Concept) -> None: ...
+
+    def __init__(self, *args) -> None:
+        assert len(args) in [1, 2]
+        assert isinstance(args[0], Concept)
+        if len(args) == 1:
+            self.__satisfiable_query_init_2(*args)
+        else:
+            assert args[1] is None or isinstance(args[1], Individual)
+            self.__satisfiable_query_init_1(*args)
+
+    def __satisfiable_query_init_1(self, c: Concept, a: Individual) -> None:
+        if c.is_concrete():
+            Util.error(f"Error: {c} cannot be a concrete concept.")
+        self.conc: Concept = c
+        self.ind: Individual = a
+        self.obj_expr: Expression = None
+
+    def __satisfiable_query_init_2(self, c: Concept) -> None:
+        self.__init__(c, None)

fuzzy_dl_owl2/fuzzydl/query/subsumption_query.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
+from fuzzy_dl_owl2.fuzzydl.query.query import Query
+from fuzzy_dl_owl2.fuzzydl.util.constants import LogicOperatorType
+from fuzzy_dl_owl2.fuzzydl.util.util import Util
+
+
+class SubsumptionQuery(Query):
+
+    def __init__(self, c1: Concept, c2: Concept, s_type: LogicOperatorType) -> None:
+        if c1.is_concrete():
+            Util.error(f"Error: {c1} cannot be a concrete concept.")
+        if c2.is_concrete():
+            Util.error(f"Error: {c1} cannot be a concrete concept.")
+        self.c1: Concept = c1
+        self.c2: Concept = c2
+        self.type: LogicOperatorType = s_type
+        self.obj_expr: Expression = None

fuzzy_dl_owl2/fuzzydl/range_axiom.py

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

fuzzy_dl_owl2/fuzzydl/relation.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
+    from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
+
+
+class Relation:
+    def __init__(
+        self, role_name: str, ind1: Individual, ind2: Individual, degree: Degree
+    ):
+        self.role_name: str = role_name
+        self.ind_a: Individual = ind1
+        self.ind_b: Individual = ind2
+        self.degree: Degree = degree
+
+    def clone(self) -> typing.Self:
+        return Relation(self.role_name, self.ind_a, self.ind_b, self.degree)
+
+    def get_subject_individual(self) -> Individual:
+        return self.ind_a
+
+    def get_object_individual(self) -> Individual:
+        return self.ind_b
+
+    def set_object_individual(self, ind: Individual) -> None:
+        self.ind_b = ind
+
+    def set_subject_individual(self, ind: Individual) -> None:
+        self.ind_a = ind
+
+    def get_role_name(self) -> str:
+        return self.role_name
+
+    def get_degree(self) -> Degree:
+        return self.degree
+
+    def get_name_without_degree(self) -> str:
+        return f"({self.ind_a}, {self.ind_b}): {self.role_name}"
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return f"{self.get_name_without_degree()} >= {self.degree}"

fuzzy_dl_owl2/fuzzydl/restriction/__init__.py

@@ -0,0 +1,2 @@
+from .restriction import Restriction
+from .has_value_restriction import HasValueRestriction

fuzzy_dl_owl2/fuzzydl/restriction/has_value_restriction.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
+from fuzzy_dl_owl2.fuzzydl.restriction.restriction import Restriction
+
+
+class HasValueRestriction(Restriction):
+    def __init__(self, role_name: str, individual: str, degree: Degree) -> None:
+        super().__init__(role_name, None, degree)
+        self.ind_name: str = individual
+
+    def get_individual(self) -> str:
+        return self.ind_name
+
+    def get_name_without_degree(self) -> str:
+        return f"(not (b-some {self.role_name} {self.ind_name}))"

fuzzy_dl_owl2/fuzzydl/restriction/restriction.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
+
+
+class Restriction:
+    def __init__(self, role_name: str, concept: Concept, degree: Degree) -> None:
+        self.role_name: str = role_name
+        self.concept: Concept = concept
+        self.degree: Degree = degree
+
+    def clone(self) -> typing.Self:
+        return Restriction(self.role_name, self.concept, self.degree)
+
+    def get_role_name(self) -> str:
+        return self.role_name
+
+    def get_degree(self) -> Degree:
+        return self.degree
+
+    def get_concept(self) -> Concept:
+        return self.concept
+
+    def get_name_without_degree(self) -> str:
+        return f"(all {self.role_name} {self.concept})"
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return f"{self.get_name_without_degree()} >= {self.degree}"

fuzzy_dl_owl2/fuzzydl/role_parent_with_degree.py

@@ -0,0 +1,10 @@
+class RoleParentWithDegree:
+    def __init__(self, parent: str, degree: float) -> None:
+        self.degree: float = degree
+        self.parent: str = parent
+
+    def get_degree(self) -> float:
+        return self.degree
+
+    def get_parent(self) -> str:
+        return self.parent

fuzzy_dl_owl2/fuzzydl/util/__init__.py

@@ -0,0 +1,3 @@
+from .config_reader import ConfigReader
+from .util import Util
+from .utils import *

fuzzy_dl_owl2/fuzzydl/util/config_reader.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import configparser
+import math
+
+
+class ConfigReader:
+    ANYWHERE_DOUBLE_BLOCKING: bool = True
+    ANYWHERE_SIMPLE_BLOCKING: bool = True
+    RELAX_MILP: bool = False
+    DEBUG_PRINT: bool = True
+    EPSILON: float = 0.001
+    MAX_INDIVIDUALS: int = -1
+    NUMBER_DIGITS: int = 2
+    OPTIMIZATIONS: int = 1
+    RULE_ACYCLIC_TBOXES: bool = True
+    SHOW_VERSION: bool = False
+    AUTHOR: bool = False
+
+    @staticmethod
+    def load_parameters(config_file: str, args: list[str]) -> None:
+        try:
+            config = configparser.ConfigParser()
+            config.read(config_file)
+
+            if len(args) > 1:
+                for i in range(0, len(args), 2):
+                    config["DEFAULT"][args[i]] = args[i + 1]
+            # else:
+            #     config["DEFAULT"] = {
+            #         "epsilon": ConfigReader.EPSILON,
+            #         "debugPrint": ConfigReader.DEBUG_PRINT,
+            #         "maxIndividuals": ConfigReader.MAX_INDIVIDUALS,
+            #         "showVersion": ConfigReader.SHOW_VERSION,
+            #         "author": False,
+            #     }
+
+            ConfigReader.RELAX_MILP = config.getboolean("DEFAULT", "relaxMilp")
+            ConfigReader.DEBUG_PRINT = config.getboolean("DEFAULT", "debugPrint")
+            ConfigReader.EPSILON = config.getfloat("DEFAULT", "epsilon")
+            ConfigReader.MAX_INDIVIDUALS = config.getint("DEFAULT", "maxIndividuals")
+            ConfigReader.NUMBER_DIGITS = int(
+                round(abs(math.log10(ConfigReader.EPSILON) - 1.0))
+            )
+            ConfigReader.SHOW_VERSION = config.getboolean("DEFAULT", "showVersion")
+
+            if ConfigReader.DEBUG_PRINT:
+                print(f"Debugging mode = {ConfigReader.DEBUG_PRINT}")
+
+            if config.getboolean("DEFAULT", "author"):
+                print("Author of python-fuzzyDL: Giuseppe Filippone")
+
+        except FileNotFoundError:
+            print(f"Error: File {config_file} not found.")
+        except Exception as e:
+            print(f"Error: {e}.")