fuzzy-dl-owl2 1.0.8__py3-none-any.whl → 1.0.10__py3-none-any.whl

fuzzy_dl_owl2/fuzzyowl2/fuzzyowl2_to_fuzzydl.py

@@ -7,6 +7,7 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import FuzzyDLKeyword
 from fuzzy_dl_owl2.fuzzydl.util.util import Util
 from fuzzy_dl_owl2.fuzzyowl2.fuzzyowl2 import FuzzyOwl2
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.choquet_concept import ChoquetConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.crisp_function import CrispFunction
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_nominal_concept import FuzzyNominalConcept
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.left_shoulder_function import (
     LeftShoulderFunction,
@@ -102,6 +103,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
             return False
 
     def __write(self, line: str) -> None:
+        Util.debug(f"Writing line to FuzzyDL file: {line}")
         with open(self.output_dl, "a") as file:
             file.write(f"{line}\n")
 
@@ -208,7 +210,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
             if len(literat_set) > 0:
                 return f"(= {self.get_data_property_name(p)} {literat_set})"
         Util.error(
-            f"Data some values restriction with range {range} and type {type} not supported -- DataSomeValuesFrom({p} {range})"
+            f"Data some values restriction with range {range} and type {type(range)} not supported -- DataSomeValuesFrom({p} {range})"
         )
         return None
 
@@ -220,7 +222,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
             if datatype_name in self.fuzzy_datatypes:
                 return f"(all {self.get_data_property_name(p)} {datatype_name})"
         Util.error(
-            f"Data all values restriction with range {range} and type {type} not supported -- DataAllValuesFrom({p} {range})"
+            f"Data all values restriction with range {range} and type {type(range)} not supported -- DataAllValuesFrom({p} {range})"
         )
         return None
 
@@ -418,25 +420,29 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         return name
 
     def write_fuzzy_logic(self, logic: str) -> None:
+        super().write_fuzzy_logic(logic)
         self.__write(f"(define-fuzzy-logic {logic})")
 
     def write_concept_declaration(self, c: OWLClassExpression) -> None:
+        super().write_concept_declaration(c)
         self.__write(
             f"(define-primitive-concept {self.get_class_name(c)} {self.get_top_concept_name()})"
         )
 
     def write_data_property_declaration(self, dp: OWLDataPropertyExpression) -> None:
+        super().write_data_property_declaration(dp)
         self.write_functional_data_property_axiom(dp)
         self.__write(f"(range {self.get_data_property_name(dp)} *string*)")
 
     def write_object_property_declaration(
         self, op: OWLObjectPropertyExpression
     ) -> None:
-        pass
+        super().write_object_property_declaration(op)
 
     def write_concept_assertion_axiom(
         self, i: OWLIndividual, c: OWLClassExpression, d: float
     ) -> None:
+        super().write_concept_assertion_axiom(i, c, d)
         self.__write(
             f"(instance {self.get_individual_name(i)} {self.get_class_name(c)} {d})"
         )
@@ -448,6 +454,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         p: OWLObjectPropertyExpression,
         d: float,
     ) -> None:
+        super().write_object_property_assertion_axiom(i1, i2, p, d)
         self.__write(
             f"(related {self.get_individual_name(i1)} {self.get_individual_name(i2)} {self.get_object_property_name(p)} {d})"
         )
@@ -459,6 +466,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         p: OWLDataPropertyExpression,
         d: float,
     ) -> None:
+        super().write_data_property_assertion_axiom(i, lit, p, d)
         datatype: OWLDatatype = lit.datatype
         dp_name: str = self.get_data_property_name(p)
         if datatype is None:
@@ -490,7 +498,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
                     else:
                         value = int(str(lit.value))
                     self.__write(
-                        f"(instance {self.get_individual_name(i)} (>= {dp_name} {value}) {d})"
+                        f"(instance {self.get_individual_name(i)} (= {dp_name} {value}) {d})"
                     )
                 else:
                     if dp_name not in self.string_datatypes:
@@ -513,6 +521,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         p: OWLObjectPropertyExpression,
         d: float,
     ) -> None:
+        super().write_negative_object_property_assertion_axiom(i1, i2, p, d)
         Util.error(
             f"Negative object property assertion not supported -- NegativeObjectPropertyAssertion({p} {i1} {i2} {d})"
         )
@@ -525,24 +534,28 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         p: OWLDataPropertyExpression,
         d: float,
     ) -> None:
+        super().write_negative_data_property_assertion_axiom(i, lit, p, d)
         Util.error(
             f"Negative data property assertion not supported -- NegativeDataPropertyAssertion({p} {i} {lit} {d})"
         )
         return None
 
     def write_same_individual_axiom(self, ind_set: set[OWLIndividual]) -> None:
+        super().write_same_individual_axiom(ind_set)
         Util.error(
-            f"Same individual axiom not supported -- NegativeDataPropertyAssertion({self.__get_set_name(ind_set)})"
+            f"Same individual axiom not supported -- SameIndividuals({self.__get_set_name(ind_set)})"
         )
         return None
 
     def write_different_individuals_axiom(self, ind_set: set[OWLIndividual]) -> None:
+        super().write_different_individuals_axiom(ind_set)
         Util.error(
             f"Different individual axiom not supported -- DifferentIndividuals({self.__get_set_name(ind_set)})"
         )
         return None
 
     def write_disjoint_classes_axiom(self, class_set: set[OWLClassExpression]) -> None:
+        super().write_disjoint_classes_axiom(class_set)
         if len(class_set) <= 1:
             return
         self.__write(
@@ -550,6 +563,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         )
 
     def write_disjoint_union_axiom(self, class_set: set[OWLClassExpression]) -> None:
+        super().write_disjoint_union_axiom(class_set)
         if len(class_set) <= 1:
             return
         for c in class_set:
@@ -562,6 +576,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_subclass_of_axiom(
         self, subclass: OWLClassExpression, superclass: OWLClassExpression, d: float
     ) -> None:
+        super().write_subclass_of_axiom(subclass, superclass, d)
         if isinstance(subclass, OWLClass) and d == 1:
             self.__write(
                 f"(define-primitive-concept {self.get_short_name(subclass)} {self.get_class_name(superclass)})"
@@ -574,6 +589,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_equivalent_classes_axiom(
         self, class_set: set[OWLClassExpression]
     ) -> None:
+        super().write_equivalent_classes_axiom(class_set)
         name: str = None
         left_class: OWLClassExpression = None
         for c in class_set:
@@ -596,6 +612,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         superproperty: OWLObjectPropertyExpression,
         d: float,
     ) -> None:
+        super().write_sub_object_property_of_axiom(subproperty, superproperty, d)
         self.__write(
             f"(implies-role {self.get_object_property_name(subproperty)} {self.get_object_property_name(superproperty)} {d})"
         )
@@ -606,6 +623,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         superproperty: OWLDataPropertyExpression,
         d: float,
     ) -> None:
+        super().write_sub_data_property_of_axiom(subproperty, superproperty, d)
         self.__write(
             f"(implies-role {self.get_data_property_name(subproperty)} {self.get_data_property_name(superproperty)} {d})"
         )
@@ -616,13 +634,16 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
         superproperty: OWLObjectPropertyExpression,
         d: float,
     ) -> None:
+        super().write_sub_property_chain_of_axiom(chain, superproperty, d)
         Util.error(
             f"Subproperty chain axiom not supported -- SubObjectPropertyOf(ObjectPropertyChain({self.__get_set_name(chain)}) {superproperty} {d})"
         )
+        return None
 
     def write_equivalent_object_properties_axiom(
         self, class_set: set[OWLObjectPropertyExpression]
     ) -> None:
+        super().write_equivalent_object_properties_axiom(class_set)
         first: OWLObjectPropertyExpression = next(class_set)
         first_name: str = self.get_object_property_name(first)
         for property in class_set - set([first]):
@@ -633,6 +654,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_equivalent_data_properties_axiom(
         self, class_set: set[OWLDataPropertyExpression]
     ) -> None:
+        super().write_equivalent_data_properties_axiom(class_set)
         first: OWLDataPropertyExpression = next(class_set)
         first_name: str = self.get_data_property_name(first)
         for property in class_set - set([first]):
@@ -643,28 +665,34 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_transitive_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_transitive_object_property_axiom(p)
         self.__write(f"(transitive {self.get_object_property_name(p)})")
 
     def write_symmetric_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_symmetric_object_property_axiom(p)
         self.__write(f"(symmetric {self.get_object_property_name(p)})")
 
     def write_asymmetric_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_asymmetric_object_property_axiom(p)
         Util.error(
             f"Asymmetric object property axiom not supported -- AsymmetricObjectProperty({p})"
         )
+        return None
 
     def write_reflexive_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_reflexive_object_property_axiom(p)
         self.__write(f"(reflexive {self.get_object_property_name(p)})")
 
     def write_irreflexive_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_irreflexive_object_property_axiom(p)
         Util.error(
             f"Irreflexive object property axiom not supported -- IrreflexiveObjectProperty({p})"
         )
@@ -672,14 +700,16 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_functional_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_functional_object_property_axiom(p)
         name: str = self.get_object_property_name(p)
         if name not in self.processed_functional_object_properties:
             self.processed_functional_object_properties.add(name)
             self.__write(f"(functional {name})")
 
     def write_functional_data_property_axiom(
-        self, p: OWLObjectPropertyExpression
+        self, p: OWLDataPropertyExpression
     ) -> None:
+        super().write_functional_data_property_axiom(p)
         name: str = self.get_data_property_name(p)
         if name not in self.processed_functional_data_properties:
             self.processed_functional_data_properties.add(name)
@@ -688,6 +718,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_inverse_object_property_axiom(
         self, p1: OWLObjectPropertyExpression, p2: OWLObjectPropertyExpression
     ) -> None:
+        super().write_inverse_object_property_axiom(p1, p2)
         self.__write(
             f"(inverse {self.get_object_property_name(p1)} {self.get_object_property_name(p2)})"
         )
@@ -695,11 +726,13 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_inverse_functional_object_property_axiom(
         self, p: OWLObjectPropertyExpression
     ) -> None:
+        super().write_inverse_functional_object_property_axiom(p)
         self.__write(f"(inverse-functional {self.get_object_property_name(p)})")
 
     def write_object_property_domain_axiom(
         self, p: OWLObjectPropertyExpression, c: OWLClassExpression
     ) -> None:
+        super().write_object_property_domain_axiom(p, c)
         self.__write(
             f"(domain {self.get_object_property_name(p)} {self.get_class_name(c)})"
         )
@@ -707,6 +740,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_object_property_range_axiom(
         self, p: OWLObjectPropertyExpression, c: OWLClassExpression
     ) -> None:
+        super().write_object_property_range_axiom(p, c)
         self.__write(
             f"(range {self.get_object_property_name(p)} {self.get_class_name(c)})"
         )
@@ -714,6 +748,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_data_property_domain_axiom(
         self, p: OWLDataPropertyExpression, c: OWLClassExpression
     ) -> None:
+        super().write_data_property_domain_axiom(p, c)
         self.__write(
             f"(domain {self.get_data_property_name(p)} {self.get_class_name(c)})"
         )
@@ -721,6 +756,7 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_data_property_range_axiom(
         self, p: OWLDataPropertyExpression, range: OWLDataRange
     ) -> None:
+        super().write_data_property_range_axiom(p, range)
         range_str: str = None
         dp_name: str = self.get_data_property_name(p)
         if isinstance(range, OWLDatatype):
@@ -809,108 +845,139 @@ class FuzzyOwl2ToFuzzyDL(FuzzyOwl2):
     def write_disjoint_object_properties_axiom(
         self, class_set: set[OWLObjectPropertyExpression]
     ) -> None:
+        super().write_disjoint_object_properties_axiom(class_set)
         Util.error(
             f"Disjoint object properties axiom not supported -- DisjointObjectProperties({self.__get_set_name(class_set)})"
         )
+        return None
 
     def write_disjoint_data_properties_axiom(
         self, class_set: set[OWLDataPropertyExpression]
     ) -> None:
+        super().write_disjoint_data_properties_axiom(class_set)
         Util.error(
             f"Disjoint data properties axiom not supported -- DisjointDataProperties({self.__get_set_name(class_set)})"
         )
+        return None
 
     def write_triangular_modifier_definition(
         self, name: str, mod: TriangularModifier
     ) -> None:
+        super().write_triangular_modifier_definition(name, mod)
         self.__write(f"(define-modifier {name} {mod})")
 
     def write_linear_modifier_definition(self, name: str, mod: LinearModifier) -> None:
+        super().write_linear_modifier_definition(name, mod)
         self.__write(f"(define-modifier {name} {mod})")
 
+    def write_crisp_function_definition(self, name: str, dat: CrispFunction) -> None:
+        super().write_crisp_function_definition(name, dat)
+        self.__write(f"(define-fuzzy-concept {name} {dat})")
+
     def write_left_shoulder_function_definition(
         self, name: str, dat: LeftShoulderFunction
     ) -> None:
+        super().write_left_shoulder_function_definition(name, dat)
         self.__write(f"(define-fuzzy-concept {name} {dat})")
 
     def write_right_shoulder_function_definition(
         self, name: str, dat: RightShoulderFunction
     ) -> None:
+        super().write_right_shoulder_function_definition(name, dat)
         self.__write(f"(define-fuzzy-concept {name} {dat})")
 
     def write_linear_function_definition(self, name: str, dat: LinearFunction) -> None:
+        super().write_linear_function_definition(name, dat)
         self.__write(f"(define-fuzzy-concept {name} {dat})")
 
     def write_triangular_function_definition(
         self, name: str, dat: TriangularFunction
     ) -> None:
+        super().write_triangular_function_definition(name, dat)
         self.__write(f"(define-fuzzy-concept {name} {dat})")
 
     def write_trapezoidal_function_definition(
         self, name: str, dat: TrapezoidalFunction
     ) -> None:
+        super().write_trapezoidal_function_definition(name, dat)
         self.__write(f"(define-fuzzy-concept {name} {dat})")
 
     def write_modified_function_definition(
         self, name: str, dat: ModifiedFunction
     ) -> None:
+        super().write_modified_function_definition(name, dat)
         self.__write(f"(define-concept {name} {dat})")
 
     def write_modified_property_definition(
         self, name: str, dat: ModifiedProperty
     ) -> None:
+        super().write_modified_property_definition(name, dat)
         Util.error(
             f"Modified property not supported -- EquivalentObjectProperties({name} <{dat.get_fuzzy_modifier()} {dat.get_property()}>)"
         )
+        return None
 
     def write_modified_concept_definition(
         self, name: str, dat: ModifiedConcept
     ) -> None:
+        super().write_modified_concept_definition(name, dat)
         self.__write(f"(define-concept {name} {dat})")
 
     def write_fuzzy_nominal_concept_definition(
         self, name: str, dat: FuzzyNominalConcept
     ) -> None:
+        super().write_fuzzy_nominal_concept_definition(name, dat)
         Util.error(
             f"Fuzzy nominal not supported -- EquivalentConcepts({name} OneOf({dat}))"
         )
+        return None
 
     def write_weighted_concept_definition(self, name: str, c: WeightedConcept) -> None:
+        super().write_weighted_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_weighted_max_concept_definition(
         self, name: str, c: WeightedMaxConcept
     ) -> None:
+        super().write_weighted_max_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_weighted_min_concept_definition(
         self, name: str, c: WeightedMinConcept
     ) -> None:
+        super().write_weighted_min_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_weighted_sum_concept_definition(
         self, name: str, c: WeightedSumConcept
     ) -> None:
+        super().write_weighted_sum_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_weighted_sum_zero_concept_definition(
         self, name: str, c: WeightedSumZeroConcept
     ) -> None:
+        super().write_weighted_sum_zero_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_owa_concept_definition(self, name: str, c: OwaConcept) -> None:
+        super().write_owa_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_choquet_concept_definition(self, name: str, c: ChoquetConcept) -> None:
+        super().write_choquet_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_sugeno_concept_definition(self, name: str, c: SugenoConcept) -> None:
+        super().write_sugeno_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_quasi_sugeno_concept_definition(
         self, name: str, c: QsugenoConcept
     ) -> None:
+        super().write_quasi_sugeno_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")
 
     def write_qowa_concept_definition(self, name: str, c: QowaConcept) -> None:
+        super().write_qowa_concept_definition(name, c)
         self.__write(f"(define-concept {name} {c})")

fuzzy_dl_owl2/fuzzyowl2/owl_types/crisp_function.py

@@ -0,0 +1,17 @@
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_datatype import FuzzyDatatype
+
+
+class CrispFunction(FuzzyDatatype):
+    def __init__(self, a: float, b: float) -> None:
+        super().__init__()
+        self._a: float = a
+        self._b: float = b
+
+    def get_a(self) -> float:
+        return self._a
+
+    def get_b(self) -> float:
+        return self._b
+
+    def __str__(self) -> str:
+        return f"crisp({self._k1}, {self._k2}, {self._a}, {self._b})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/fuzzy_nominal_concept.py

@@ -16,4 +16,4 @@ class FuzzyNominalConcept(ConceptDefinition):
         return self._i
 
     def __str__(self) -> str:
-        return f"({self.get_degree()}, {self.get_individual()})"
+        return f"({self.get_degree()} {self.get_individual()})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_concept.py

@@ -16,4 +16,4 @@ class ModifiedConcept(ConceptDefinition):
         return self._c
 
     def __str__(self) -> str:
-        return f"({self._mod}, {self._c})"
+        return f"({self._mod} {self._c})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_function.py

@@ -14,4 +14,4 @@ class ModifiedFunction(FuzzyDatatype):
         return self._d
 
     def __str__(self) -> str:
-        return f"({self._mod}, {self._d})"
+        return f"({self._mod} {self._d})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/modified_property.py

@@ -18,4 +18,4 @@ class ModifiedProperty(FuzzyProperty):
         return str(self)
 
     def __str__(self) -> str:
-        return f"({self.get_fuzzy_modifier()}, {self.get_property()})"
+        return f"({self.get_fuzzy_modifier()} {self.get_property()})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_max_concept.py

@@ -12,4 +12,4 @@ class WeightedMaxConcept(ConceptDefinition):
         return self._wc
 
     def __str__(self) -> str:
-        return f"(w-max {self._wc})"
+        return f"(w-max {' '.join(map(str, self._wc))})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_min_concept.py

@@ -12,4 +12,4 @@ class WeightedMinConcept(ConceptDefinition):
         return self._wc
 
     def __str__(self) -> str:
-        return f"(w-min {self._wc})"
+        return f"(w-min {' '.join(map(str, self._wc))})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_sum_concept.py

@@ -12,4 +12,4 @@ class WeightedSumConcept(ConceptDefinition):
         return self._wc
 
     def __str__(self) -> str:
-        return f"(w-sum {self._wc})"
+        return f"(w-sum {' '.join(map(str, self._wc))})"

fuzzy_dl_owl2/fuzzyowl2/owl_types/weighted_sum_zero_concept.py

@@ -12,4 +12,4 @@ class WeightedSumZeroConcept(ConceptDefinition):
         return self._wc
 
     def __str__(self) -> str:
-        return f"(w-sum-zero {self._wc})"
+        return f"(w-sum-zero {' '.join(map(str, self._wc))})"

fuzzy_dl_owl2/fuzzyowl2/parser/owl2_xml_parser.py

@@ -10,6 +10,7 @@ import pyparsing as pp
 from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
 from fuzzy_dl_owl2.fuzzydl.util.util import Util
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.choquet_concept import ChoquetConcept
+from fuzzy_dl_owl2.fuzzyowl2.owl_types.crisp_function import CrispFunction
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.fuzzy_nominal_concept import FuzzyNominalConcept
 from fuzzy_dl_owl2.fuzzyowl2.owl_types.left_shoulder_function import (
     LeftShoulderFunction,
@@ -140,7 +141,7 @@ class FuzzyOwl2XMLParser(object):
             elif concept_type == FuzzyOWL2Keyword.NOMINAL:
                 return FuzzyNominalConcept(
                     float(
-                        child.attrib.get(FuzzyOWL2Keyword.DEGREE_DEF.get_str_value())
+                        child.attrib.get(FuzzyOWL2Keyword.DEGREE_VALUE.get_str_value())
                     ),
                     child.attrib.get(FuzzyOWL2Keyword.INDIVIDUAL.get_str_value()),
                 )
@@ -148,7 +149,12 @@ class FuzzyOwl2XMLParser(object):
             child = root.find(FuzzyOWL2Keyword.DATATYPE.get_tag_name())
             datatype_type = child.attrib.get(FuzzyOWL2Keyword.TYPE.get_str_value())
 
-            if datatype_type == FuzzyOWL2Keyword.LEFT_SHOULDER:
+            if datatype_type == FuzzyOWL2Keyword.CRISP:
+                return CrispFunction(
+                    float(child.attrib.get(FuzzyOWL2Keyword.A.get_str_value())),
+                    float(child.attrib.get(FuzzyOWL2Keyword.B.get_str_value())),
+                )
+            elif datatype_type == FuzzyOWL2Keyword.LEFT_SHOULDER:
                 return LeftShoulderFunction(
                     float(child.attrib.get(FuzzyOWL2Keyword.A.get_str_value())),
                     float(child.attrib.get(FuzzyOWL2Keyword.B.get_str_value())),