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

fuzzy_dl_owl2/fuzzydl/concept/owa_concept.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+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 OwaConcept(Concept, HasWeightedConceptsInterface):
+    def __init__(self, weights: list[float], concepts: list[Concept]) -> None:
+        Concept.__init__(self, ConceptType.OWA)
+        HasWeightedConceptsInterface.__init__(self, weights, concepts)
+
+        if weights is not None:
+            if len(weights) != len(concepts):
+                Util.error(
+                    "Error: The number of weights and the number of concepts should be the same"
+                )
+            self.name = self.compute_name()
+
+    def clone(self) -> typing.Self:
+        return OwaConcept(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) -> typing.Optional[Concept]:
+        return -OwaConcept(self.weights, [ci.replace(a, c) for ci in self.concepts])
+
+    def compute_name(self) -> str:
+        return f"(owa ({' '.join(map(str, self.weights))}) ({' '.join(map(str, self.concepts))}))"
+
+    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/qowa_concept.py

@@ -0,0 +1,62 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.concrete.fuzzy_concrete_concept import (
+    FuzzyConcreteConcept,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.concept.owa_concept import OwaConcept
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+
+
+class QowaConcept(OwaConcept):
+    def __init__(
+        self, quantifier: FuzzyConcreteConcept, concepts: list[Concept]
+    ) -> None:
+        super().__init__(None, concepts)
+
+        self.type = ConceptType.QUANTIFIED_OWA
+        self._quantifier: FuzzyConcreteConcept = quantifier
+        self.compute_weights(len(concepts))
+        self.name = self.compute_name()
+
+    @property
+    def quantifier(self) -> FuzzyConcreteConcept:
+        return self._quantifier
+
+    @quantifier.setter
+    def quantifier(self, value: FuzzyConcreteConcept) -> None:
+        self._quantifier = value
+        self.name = self.compute_name()
+
+    def clone(self) -> typing.Self:
+        return QowaConcept(self.quantifier, [c for c in self.concepts])
+
+    def compute_weights(self, n: int) -> None:
+        if n <= 0:
+            return
+        if self.weights is None:
+            self.weights = []
+        previous: float = 0.0
+        for i in range(1, n + 1):
+            w: float = i / n
+            self.weights.append(self.quantifier.get_membership_degree(w - previous))
+            previous: float = w
+
+    def replace(self, a: Concept, c: Concept) -> typing.Optional[Concept]:
+        return -OwaConcept(self.quantifier, [ci.replace(a, c) for ci in self.concepts])
+
+    def compute_name(self) -> str:
+        return f"(q-owa {self.quantifier} {' '.join(map(str, self.concepts))})"
+
+    def __neg__(self) -> Concept:
+        return OperatorConcept.not_(OwaConcept(self.weights, self.concepts))
+
+    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/quasi_sugeno_integral.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.concept.sugeno_integral import SugenoIntegral
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+from fuzzy_dl_owl2.fuzzydl.util.util import Util
+
+
+class QsugenoIntegral(SugenoIntegral):
+
+    def __init__(self, weights: list[float], concepts: list[Concept]) -> None:
+        super().__init__(weights, concepts)
+        self.type = ConceptType.QUASI_SUGENO_INTEGRAL
+
+        if weights is not None:
+            if len(weights) != len(concepts):
+                Util.error(
+                    "Error: The number of weights and the number of concepts should be the same"
+                )
+            self.name = self.compute_name()
+
+    def clone(self) -> typing.Self:
+        return QsugenoIntegral(self.weights[:], [c for c in self.concepts])
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        return -QsugenoIntegral(
+            self.weights, [ci.replace(a, c) for ci in self.concepts]
+        )
+
+    def compute_name(self) -> str:
+        return f"(qsugeno ({' '.join(map(str, self.weights))}) ({' '.join(map(str, self.concepts))}))"
+
+    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/self_concept.py

@@ -0,0 +1,45 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_role_interface import HasRoleInterface
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+
+
+class SelfConcept(Concept, HasRoleInterface):
+
+    def __init__(self, role: str) -> None:
+        Concept.__init__(self, ConceptType.SELF)
+        HasRoleInterface.__init__(self, role)
+        self.name = self.compute_name()
+
+    @staticmethod
+    def self(role: str) -> typing.Self:
+        return SelfConcept(role)
+
+    def clone(self):
+        return SelfConcept(self.role)
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        return self
+
+    def compute_name(self) -> typing.Optional[str]:
+        return f"(self {self.role})"
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        return set([self])
+
+    def get_roles(self) -> set[str]:
+        return set([self.role])
+
+    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/string_concept.py

@@ -0,0 +1,35 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.exception.fuzzy_ontology_exception import (
+    FuzzyOntologyException,
+)
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+
+
+class StringConcept(Concept):
+
+    def __init__(self, name: str) -> None:
+        super().__init__(ConceptType.ATOMIC)
+        self._name: str = name
+
+    def clone(self) -> typing.Self:
+        return StringConcept(self.name)
+
+    def compute_name(self) -> str | None:
+        return f'"{self.name}"'
+
+    def get_roles(self) -> set[str]:
+        return set()
+
+    def compute_atomic_concepts(self) -> set[typing.Self]:
+        return set()
+
+    def replace(self, a: typing.Self, c: typing.Self) -> typing.Self | None:
+        return self
+
+    def __neg__(self) -> typing.Self:
+        raise FuzzyOntologyException("Strings cannot be complemented")
+
+    def __hash__(self) -> int:
+        return hash(str(self))

fuzzy_dl_owl2/fuzzydl/concept/sugeno_integral.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import typing
+
+import trycast
+
+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 SugenoIntegral(Concept, HasWeightedConceptsInterface):
+
+    @typing.overload
+    def __init__(self) -> None: ...
+
+    @typing.overload
+    def __init__(
+        self, weights: typing.Optional[list[float]], concepts: list[Concept]
+    ) -> None: ...
+
+    def __init__(self, *args) -> None:
+        assert len(args) in [0, 2]
+        if len(args) == 0:
+            self.__sugeno_init_1()
+        else:
+            trycast.checkcast(typing.Optional[list[float]], args[0])
+            trycast.checkcast(list[Concept], args[1])
+            self.__sugeno_init_2(*args)
+
+    def __sugeno_init_1(self) -> None:
+        Concept.__init__(self, ConceptType.SUGENO_INTEGRAL)
+        HasWeightedConceptsInterface.__init__(self, None, [])
+
+    def __sugeno_init_2(
+        self, weights: typing.Optional[list[float]], concepts: list[Concept]
+    ) -> None:
+        Concept.__init__(self, ConceptType.SUGENO_INTEGRAL)
+        HasWeightedConceptsInterface.__init__(self, weights, concepts)
+
+        if weights is not None:
+            if len(weights) != len(concepts):
+                Util.error(
+                    "Error: The number of weights and the number of concepts should be the same"
+                )
+            self.name = self.compute_name()
+
+    def clone(self) -> typing.Self:
+        return SugenoIntegral(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 -SugenoIntegral(self.weights, [ci.replace(a, c) for ci in self.concepts])
+
+    def compute_name(self) -> str:
+        return f"(sugeno ({' '.join(map(str, self.weights))}) ({' '.join(map(str, self.concepts))}))"
+
+    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/threshold_concept.py

@@ -0,0 +1,81 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_concept_interface import (
+    HasConceptInterface,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+
+
+class ThresholdConcept(Concept, HasConceptInterface):
+
+    def __init__(self, c_type: ConceptType, c: Concept, weight: float) -> None:
+        Concept.__init__(self, c_type)
+        HasConceptInterface.__init__(self, c)
+
+        assert c_type in (
+            ConceptType.POS_THRESHOLD,
+            ConceptType.NEG_THRESHOLD,
+        )
+
+        self._weight: float = weight
+        self.name = self.compute_name()
+
+    @property
+    def weight(self) -> float:
+        return self._weight
+
+    @weight.setter
+    def weight(self, value: float) -> None:
+        self._weight = value
+
+    @staticmethod
+    def pos_threshold(w: float, c: typing.Self) -> typing.Self:
+        return ThresholdConcept(ConceptType.POS_THRESHOLD, c, w)
+
+    @staticmethod
+    def neg_threshold(w: float, c: typing.Self) -> typing.Self:
+        return ThresholdConcept(ConceptType.NEG_THRESHOLD, c, w)
+
+    def clone(self) -> typing.Self:
+        return ThresholdConcept(self.type, self.curr_concept, self.weight)
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        c_type: ConceptType = c.type
+        if c_type == ConceptType.POS_THRESHOLD:
+            return ThresholdConcept.pos_threshold(
+                self.weight, self.curr_concept.replace(a, c)
+            )
+        elif c_type == ConceptType.NEG_THRESHOLD:
+            return ThresholdConcept.neg_threshold(
+                self.weight, self.curr_concept.replace(a, c)
+            )
+
+    def compute_name(self) -> typing.Optional[str]:
+        if self.type == ConceptType.POS_THRESHOLD:
+            return f"([>= {self.weight}] {self.curr_concept})"
+        elif self.type == ConceptType.NEG_THRESHOLD:
+            return f"([<= {self.weight}] {self.curr_concept})"
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        return self.curr_concept.compute_atomic_concepts()
+
+    def get_roles(self) -> set[str]:
+        return self.curr_concept.get_roles()
+
+    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))
+
+
+PosThreshold = ThresholdConcept.pos_threshold
+NegThreshold = ThresholdConcept.neg_threshold

fuzzy_dl_owl2/fuzzydl/concept/truth_concept.py

@@ -0,0 +1,83 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+
+
+class TruthConcept(Concept):
+    def __init__(self, c_type: ConceptType) -> None:
+        assert c_type in (ConceptType.TOP, ConceptType.BOTTOM)
+        if c_type == ConceptType.TOP:
+            super().__init__(ConceptType.TOP)
+        else:
+            super().__init__(ConceptType.BOTTOM)
+        self.name = self.compute_name()
+
+    @staticmethod
+    def get_top():
+        return TruthConcept(ConceptType.TOP)
+
+    @staticmethod
+    def get_bottom():
+        return TruthConcept(ConceptType.BOTTOM)
+
+    def is_atomic(self) -> bool:
+        return True
+
+    def is_complemented_atomic(self) -> bool:
+        return False
+
+    def clone(self) -> typing.Self:
+        return TruthConcept(self.type)
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        return self
+
+    def compute_name(self) -> typing.Optional[str]:
+        if self.type == ConceptType.TOP:
+            return "*top*"
+        elif self.type == ConceptType.BOTTOM:
+            return "*bottom*"
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        return set()
+
+    def get_atomic_concepts(self) -> set[typing.Self]:
+        return set([self])
+
+    def get_atoms(self) -> list[typing.Self]:
+        return [self]
+
+    def get_roles(self) -> set[str]:
+        return set()
+
+    def __and__(self, value: typing.Self) -> typing.Self:
+        return value if self.type == ConceptType.TOP else TruthConcept.get_bottom()
+
+    def __or__(self, value: typing.Self) -> typing.Self:
+        return TruthConcept.get_top() if self.type == ConceptType.TOP else value
+
+    def __rshift__(self, value: Concept) -> Concept:
+        if self.type == ConceptType.TOP:
+            return value
+        else:
+            return TruthConcept.get_top()
+
+    def __neg__(self) -> typing.Self:
+        if self.type == ConceptType.TOP:
+            return TruthConcept(ConceptType.BOTTOM)
+        else:
+            return TruthConcept(ConceptType.TOP)
+
+    def __hash__(self) -> int:
+        return hash(self.name)
+
+    def __eq__(self, value: typing.Self) -> bool:
+        return isinstance(value, TruthConcept) and str(self) == str(value)
+
+    def __ne__(self, value: typing.Self) -> bool:
+        return not (self == value)
+
+
+TOP: Concept = TruthConcept.get_top()
+BOTTOM: Concept = TruthConcept.get_bottom()

fuzzy_dl_owl2/fuzzydl/concept/value_concept.py

@@ -0,0 +1,67 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_value_interface import (
+    HasValueInterface,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+
+
+class ValueConcept(Concept, HasValueInterface):
+
+    def __init__(self, c_type: ConceptType, role: str, value: typing.Any) -> None:
+        Concept.__init__(self, c_type)
+        HasValueInterface.__init__(self, role, value)
+
+        assert c_type in (
+            ConceptType.AT_LEAST_VALUE,
+            ConceptType.AT_LEAST_VALUE,
+            ConceptType.EXACT_VALUE,
+        )
+
+        self.name = self.compute_name()
+
+    @staticmethod
+    def at_most_value(role: str, o: typing.Any) -> typing.Self:
+        return ValueConcept(ConceptType.AT_MOST_VALUE, role, o)
+
+    @staticmethod
+    def at_least_value(role: str, o: typing.Any) -> typing.Self:
+        return ValueConcept(ConceptType.AT_LEAST_VALUE, role, o)
+
+    @staticmethod
+    def exact_value(role: str, o: typing.Any) -> typing.Self:
+        return ValueConcept(ConceptType.EXACT_VALUE, role, o)
+
+    def clone(self) -> typing.Self:
+        return ValueConcept(self.type, self.role, self.value)
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        return self
+
+    def compute_name(self) -> typing.Optional[str]:
+        if self.type == ConceptType.AT_MOST_VALUE:
+            return f"(<= {self.role} {self.value})"
+        elif self.type == ConceptType.AT_LEAST_VALUE:
+            return f"(>= {self.role} {self.value})"
+        elif self.type == ConceptType.EXACT_VALUE:
+            return f"(= {self.role} {self.value})"
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        return set()
+
+    def get_roles(self) -> set[str]:
+        return set()
+
+    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_concept.py

@@ -0,0 +1,55 @@
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
+from fuzzy_dl_owl2.fuzzydl.concept.interface.has_concept_interface import (
+    HasConceptInterface,
+)
+from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
+from fuzzy_dl_owl2.fuzzydl.util.constants import ConceptType
+
+
+class WeightedConcept(Concept, HasConceptInterface):
+
+    def __init__(self, weight: float, c: Concept) -> None:
+        Concept.__init__(self, ConceptType.WEIGHTED)
+        HasConceptInterface.__init__(self, c)
+
+        self._weight: float = weight
+        self.name = self.compute_name()
+
+    @property
+    def weight(self) -> float:
+        return self._weight
+
+    @weight.setter
+    def weight(self, value: float) -> None:
+        self._weight = value
+
+    def clone(self) -> typing.Self:
+        return WeightedConcept(self.weight, self.curr_concept)
+
+    def replace(self, a: Concept, c: Concept) -> Concept:
+        c_type: ConceptType = c.type
+        if c_type == ConceptType.WEIGHTED:
+            return WeightedConcept(self.weight, self.curr_concept.replace(a, c))
+
+    def compute_name(self) -> typing.Optional[str]:
+        return f"({self.weight} {self.curr_concept})"
+
+    def compute_atomic_concepts(self) -> set[Concept]:
+        return self.curr_concept.compute_atomic_concepts()
+
+    def get_roles(self) -> set[str]:
+        return self.curr_concept.get_roles()
+
+    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_max_concept.py

@@ -0,0 +1,63 @@
+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 WeightedMaxConcept(Concept, HasWeightedConceptsInterface):
+
+    def __init__(self, weights: list[float], concepts: list[Concept]) -> None:
+        Concept.__init__(self, ConceptType.W_MAX)
+        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 not any(w == 1.0 for w in weights):
+            Util.error(
+                "Error: Some of the weights of the weighted max concept must be 1.0."
+            )
+
+        self.name = self.compute_name()
+
+    def clone(self) -> typing.Self:
+        return WeightedMaxConcept(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 -WeightedMaxConcept(
+            self.weights, [ci.replace(a, c) for ci in self.concepts]
+        )
+
+    def compute_name(self) -> str:
+        return f"(w-max {' '.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))