def test_diagonal(self):
base_set = Set(Atom(1))
diag_rels = [relations.diag(*base_set), relations.diag(1)]
for diag_rel in diag_rels:
self.assertEqual(diag_rel.cardinality, 1)
self.assertTrue(relations.is_member(diag_rel))
self.assertTrue(diag_rel.has_element(Couplet(1, 1)))
base_set = Set(Atom(1), Atom('a'))
diag_clan = clans.diag(1, 'a')
self.assertEqual(diag_clan.cardinality, 1)
diag_rels = [
relations.diag(*base_set),
relations.diag(1, 'a'),
sets.single(diag_clan)
]
for diag_rel in diag_rels:
self.assertEqual(diag_rel.cardinality, 2)
self.assertTrue(relations.is_member(diag_rel))
self.assertTrue(diag_rel.has_element(Couplet(1, 1)))
self.assertTrue(diag_rel.has_element(Couplet('a', 'a')))
arg1 = Set(1, 2, 3)
arg2 = [v for v in Set(1, 2, 3)]
result_diag = Set(Couplet(1, 1), Couplet(2, 2), Couplet(3, 3))
self.assertEqual(relations.diag(*arg1), result_diag)
self.assertEqual(relations.diag(*arg2), result_diag)
def test_diagonal(self):
base_set = Set(Atom(1))
diag_rels = [
relations.diag(*base_set), relations.diag(1)]
for diag_rel in diag_rels:
self.assertEqual(diag_rel.cardinality, 1)
self.assertTrue(relations.is_member(diag_rel))
self.assertTrue(diag_rel.has_element(Couplet(1, 1)))
base_set = Set(Atom(1), Atom('a'))
diag_clan = clans.diag(1, 'a')
self.assertEqual(diag_clan.cardinality, 1)
diag_rels = [
relations.diag(*base_set), relations.diag(1, 'a'), sets.single(diag_clan)]
for diag_rel in diag_rels:
self.assertEqual(diag_rel.cardinality, 2)
self.assertTrue(relations.is_member(diag_rel))
self.assertTrue(diag_rel.has_element(Couplet(1, 1)))
self.assertTrue(diag_rel.has_element(Couplet('a', 'a')))
arg1 = Set(1, 2, 3)
arg2 = [v for v in Set(1, 2, 3)]
result_diag = Set(Couplet(1, 1), Couplet(2, 2), Couplet(3, 3))
self.assertEqual(relations.diag(*arg1), result_diag)
self.assertEqual(relations.diag(*arg2), result_diag)
def is_absolute_member(obj: _mo.MathObject) -> bool:
"""Return whether ``obj`` is a member of the :term:`absolute ground set` of this algebra.
:return: ``True`` if ``obj`` is an :term:`absolute set`, ``False`` if not.
"""
if not obj.is_set:
# If known to not be a set, it's also not an absolute set. No further checking or caching.
return False
# From this point on, `obj` is known to be a set.
if obj.cached_absolute == _mo.CacheStatus.UNKNOWN:
import algebraixlib.algebras.clans as _clans
import algebraixlib.algebras.relations as _relations
# In order to find out whether this is an absolute set, we need to know whether `obj` is a
# relation or a clan (both sets). If it is one of these, it is not an absolute set -- but
# we also don't know whether it is an absolute relation or clan. So we return `False` but
# don't cache anything. (But we have now cached that it is a relation or a clan.)
if _relations.is_member(obj) or _clans.is_member(obj):
return False
is_absolute_set = all(elem.is_atom for elem in obj)
obj.cache_absolute(_mo.CacheStatus.from_bool(is_absolute_set))
# In order to determine whether this is an absolute set, we need to also examine whether this
# is a relation or a clan (both are sets). Absolute relations and absolute clans are not
# absolute sets.
return obj.cached_is_absolute and not obj.cached_is_relation and not obj.cached_is_clan
def is_absolute_member(obj: _mo.MathObject) -> bool:
"""Return whether ``obj`` is a member of the :term:`absolute ground set` of this algebra.
:return: ``True`` if ``obj`` is an :term:`absolute set`, ``False`` if not.
"""
if not obj.is_set:
# If known to not be a set, it's also not an absolute set. No further checking or caching.
return False
# From this point on, `obj` is known to be a set.
if obj.cached_absolute == _mo.CacheStatus.UNKNOWN:
import algebraixlib.algebras.clans as _clans
import algebraixlib.algebras.relations as _relations
# In order to find out whether this is an absolute set, we need to know whether `obj` is a
# relation or a clan (both sets). If it is one of these, it is not an absolute set -- but
# we also don't know whether it is an absolute relation or clan. So we return `False` but
# don't cache anything. (But we have now cached that it is a relation or a clan.)
if _relations.is_member(obj) or _clans.is_member(obj):
return False
is_absolute_set = all(elem.is_atom for elem in obj)
obj.cache_absolute(_mo.CacheStatus.from_bool(is_absolute_set))
# In order to determine whether this is an absolute set, we need to also examine whether this
# is a relation or a clan (both are sets). Absolute relations and absolute clans are not
# absolute sets.
return obj.cached_is_absolute and not obj.cached_is_relation and not obj.cached_is_clan
def test_flags_relation(self):
r = Set(Couplet(s, c) for s, c in zip('abc', [1, 2, 3]))
self.assertEqual(r.cached_relation, CacheStatus.UNKNOWN)
self.assertEqual(r.cached_clan, CacheStatus.UNKNOWN)
self.assertTrue(sets.is_member(r)) # This will NOT trigger structure check
self.assertEqual(r.cached_relation, CacheStatus.UNKNOWN)
self.assertEqual(r.cached_clan, CacheStatus.UNKNOWN)
self.assertTrue(relations.is_member(r)) # This will trigger structure check
self.assertEqual(r.cached_relation, CacheStatus.IS)
self.assertEqual(r.cached_clan, CacheStatus.IS_NOT)
def test_flags_set(self):
s = Set(1, 2, 3)
self.assertEqual(s.cached_relation, CacheStatus.UNKNOWN)
self.assertEqual(s.cached_clan, CacheStatus.UNKNOWN)
self.assertTrue(sets.is_member(s)) # This will NOT trigger structure check
self.assertEqual(s.cached_relation, CacheStatus.UNKNOWN)
self.assertEqual(s.cached_clan, CacheStatus.UNKNOWN)
self.assertFalse(relations.is_member(s)) # This will trigger structure check
self.assertEqual(s.cached_relation, CacheStatus.IS_NOT)
self.assertEqual(s.cached_clan, CacheStatus.UNKNOWN)
def test_flags_relation(self):
r = Set(Couplet(s, c) for s, c in zip("abc", [1, 2, 3]))
self.assertEqual(r.cached_relation, CacheStatus.UNKNOWN)
self.assertEqual(r.cached_clan, CacheStatus.UNKNOWN)
self.assertTrue(sets.is_member(r)) # This will NOT trigger structure check
self.assertEqual(r.cached_relation, CacheStatus.UNKNOWN)
self.assertEqual(r.cached_clan, CacheStatus.UNKNOWN)
self.assertTrue(relations.is_member(r)) # This will trigger structure check
self.assertEqual(r.cached_relation, CacheStatus.IS)
self.assertEqual(r.cached_clan, CacheStatus.IS_NOT)
def test_flags_set(self):
s = Set(1, 2, 3)
self.assertEqual(s.cached_relation, CacheStatus.UNKNOWN)
self.assertEqual(s.cached_clan, CacheStatus.UNKNOWN)
self.assertTrue(sets.is_member(s)) # This will NOT trigger structure check
self.assertEqual(s.cached_relation, CacheStatus.UNKNOWN)
self.assertEqual(s.cached_clan, CacheStatus.UNKNOWN)
self.assertFalse(relations.is_member(s)) # This will trigger structure check
self.assertEqual(s.cached_relation, CacheStatus.IS_NOT)
self.assertEqual(s.cached_clan, CacheStatus.UNKNOWN)
def test_union_flags(self):
s1 = Set(1)
s2 = Set(2)
s3 = Set(1, 2)
self.assertTrue(is_absolute_member(s1))
self.assertTrue(is_absolute_member(s2))
self.assertTrue(is_absolute_member(s3))
result = union(s1, s2)
self.assertEqual(s3, result)
self.assertEqual(result.cached_is_absolute, CacheStatus.IS)
from algebraixlib.algebras import relations as _rels
rel1 = Set(Couplet('a', 1))
rel2 = Set(Couplet('b', 2))
rel3 = Set(Couplet('a', 1), Couplet('b', 2))
self.assertTrue(_rels.is_absolute_member(rel1))
self.assertTrue(_rels.is_absolute_member(rel2))
result = union(rel1, rel2)
self.assertEqual(rel3, result)
self.assertEqual(result.cached_is_absolute, CacheStatus.IS)
from algebraixlib.algebras import clans as _clans
clan1 = Set(rel1)
clan2 = Set(rel2)
clan3 = Set(rel1, rel2)
self.assertTrue(_clans.is_absolute_member(clan1))
self.assertTrue(_clans.is_absolute_member(clan2))
self.assertTrue(_clans.is_functional(clan1))
self.assertTrue(_clans.is_functional(clan2))
self.assertTrue(_clans.is_right_functional(clan1))
self.assertTrue(_clans.is_right_functional(clan2))
result = union(clan1, clan2)
self.assertEqual(clan3, result)
self.assertEqual(result.cached_absolute, CacheStatus.IS)
self.assertEqual(result.cached_functional, CacheStatus.IS)
self.assertEqual(result.cached_right_functional, CacheStatus.IS)
clan4 = Set(Set(Couplet(s1, 1), Couplet(s1, 2)))
clan5 = Set(rel1, Set(Couplet(s1, 1), Couplet(s1, 2)))
self.assertFalse(_clans.is_absolute_member(clan4))
self.assertFalse(_clans.is_functional(clan4))
result = union(clan1, clan4)
self.assertEqual(clan5, result)
self.assertEqual(result.cached_absolute, CacheStatus.IS_NOT)
self.assertEqual(result.cached_functional, CacheStatus.IS_NOT)
rel1 = Set(Couplet('a', 1), Couplet('b',
2)).cache_relation(CacheStatus.IS)
rel2 = Set(Couplet('c', 3))
self.assertEqual(
union(rel1, rel2).cached_relation, CacheStatus.UNKNOWN)
self.assertTrue(_rels.is_member(rel2))
self.assertEqual(union(rel1, rel2).cached_relation, CacheStatus.IS)
def test_union_flags(self):
s1 = Set(1)
s2 = Set(2)
s3 = Set(1, 2)
self.assertTrue(is_absolute_member(s1))
self.assertTrue(is_absolute_member(s2))
self.assertTrue(is_absolute_member(s3))
result = union(s1, s2)
self.assertEqual(s3, result)
self.assertEqual(result.cached_is_absolute, CacheStatus.IS)
from algebraixlib.algebras import relations as _rels
rel1 = Set(Couplet('a', 1))
rel2 = Set(Couplet('b', 2))
rel3 = Set(Couplet('a', 1), Couplet('b', 2))
self.assertTrue(_rels.is_absolute_member(rel1))
self.assertTrue(_rels.is_absolute_member(rel2))
result = union(rel1, rel2)
self.assertEqual(rel3, result)
self.assertEqual(result.cached_is_absolute, CacheStatus.IS)
from algebraixlib.algebras import clans as _clans
clan1 = Set(rel1)
clan2 = Set(rel2)
clan3 = Set(rel1, rel2)
self.assertTrue(_clans.is_absolute_member(clan1))
self.assertTrue(_clans.is_absolute_member(clan2))
self.assertTrue(_clans.is_functional(clan1))
self.assertTrue(_clans.is_functional(clan2))
self.assertTrue(_clans.is_right_functional(clan1))
self.assertTrue(_clans.is_right_functional(clan2))
result = union(clan1, clan2)
self.assertEqual(clan3, result)
self.assertEqual(result.cached_absolute, CacheStatus.IS)
self.assertEqual(result.cached_functional, CacheStatus.IS)
self.assertEqual(result.cached_right_functional, CacheStatus.IS)
clan4 = Set(Set(Couplet(s1, 1), Couplet(s1, 2)))
clan5 = Set(rel1, Set(Couplet(s1, 1), Couplet(s1, 2)))
self.assertFalse(_clans.is_absolute_member(clan4))
self.assertFalse(_clans.is_functional(clan4))
result = union(clan1, clan4)
self.assertEqual(clan5, result)
self.assertEqual(result.cached_absolute, CacheStatus.IS_NOT)
self.assertEqual(result.cached_functional, CacheStatus.IS_NOT)
rel1 = Set(Couplet('a', 1), Couplet('b', 2)).cache_relation(CacheStatus.IS)
rel2 = Set(Couplet('c', 3))
self.assertEqual(union(rel1, rel2).cached_relation, CacheStatus.UNKNOWN)
self.assertTrue(_rels.is_member(rel2))
self.assertEqual(union(rel1, rel2).cached_relation, CacheStatus.IS)
def is_reflexive(mo: _mo.MathObject, _checked: bool = True) -> bool:
r"""Return whether ``mo`` is :term:`reflexive` or `Undef()` if not applicable.
Is implemented for :term:`couplet`\s, :term:`relation`\s, :term:`clan`\s, :term:`multiclan`\s
and :term:`set`\s of (sets of ...) clans. Is also defined (but not yet implemented) for any
combination of sets or :term:`multiset`\s of relations.
"""
# pylint: disable=too-many-return-statements
if _checked:
if not isinstance(mo, _mo.MathObject):
return _undef.make_or_raise_undef()
# Check cache status.
if mo.cached_reflexive == _mo.CacheStatus.IS:
return True
if mo.cached_reflexive == _mo.CacheStatus.IS_NOT:
return False
if mo.cached_reflexive == _mo.CacheStatus.N_A:
return _undef.make_or_raise_undef(2)
# Check types and algebra memberships.
if _couplets.is_member(mo):
return _couplets.is_reflexive(mo, _checked=False)
if not mo.is_set and not mo.is_multiset:
mo.cache_reflexive(_mo.CacheStatus.N_A)
return _undef.make_or_raise_undef(2)
if _relations.is_member(mo):
return _relations.is_reflexive(mo, _checked=False)
if _clans.is_member(mo):
return _clans.is_reflexive(mo, _checked=False)
if _multiclans.is_member(mo):
return _multiclans.is_reflexive(mo, _checked=False)
# Check higher (not yet defined) algebras.
reflexive = _is_powerset_property(mo, _clans.get_ground_set(),
is_reflexive)
if reflexive is not _undef.Undef():
mo.cache_reflexive(_mo.CacheStatus.from_bool(reflexive))
return reflexive
# Nothing applied: 'reflexive' is not defined.
mo.cache_reflexive(_mo.CacheStatus.N_A)
return _undef.make_or_raise_undef(2)
def is_reflexive(mo: _mo.MathObject, _checked: bool=True) -> bool:
r"""Return whether ``mo`` is :term:`reflexive` or `Undef()` if not applicable.
Is implemented for :term:`couplet`\s, :term:`relation`\s, :term:`clan`\s, :term:`multiclan`\s
and :term:`set`\s of (sets of ...) clans. Is also defined (but not yet implemented) for any
combination of sets or :term:`multiset`\s of relations.
"""
# pylint: disable=too-many-return-statements
if _checked:
if not isinstance(mo, _mo.MathObject):
return _undef.make_or_raise_undef()
# Check cache status.
if mo.cached_reflexive == _mo.CacheStatus.IS:
return True
if mo.cached_reflexive == _mo.CacheStatus.IS_NOT:
return False
if mo.cached_reflexive == _mo.CacheStatus.N_A:
return _undef.make_or_raise_undef(2)
# Check types and algebra memberships.
if _couplets.is_member(mo):
return _couplets.is_reflexive(mo, _checked=False)
if not mo.is_set and not mo.is_multiset:
mo.cache_reflexive(_mo.CacheStatus.N_A)
return _undef.make_or_raise_undef(2)
if _relations.is_member(mo):
return _relations.is_reflexive(mo, _checked=False)
if _clans.is_member(mo):
return _clans.is_reflexive(mo, _checked=False)
if _multiclans.is_member(mo):
return _multiclans.is_reflexive(mo, _checked=False)
# Check higher (not yet defined) algebras.
reflexive = _is_powerset_property(mo, _clans.get_ground_set(), is_reflexive)
if reflexive is not _undef.Undef():
mo.cache_reflexive(_mo.CacheStatus.from_bool(reflexive))
return reflexive
# Nothing applied: 'reflexive' is not defined.
mo.cache_reflexive(_mo.CacheStatus.N_A)
return _undef.make_or_raise_undef(2)
def is_triple(obj: _mo.MathObject) -> bool:
"""Return ``True`` if ``obj`` is a valid `triple`, ``False`` if not."""
# noinspection PyTypeChecker
return _relations.is_member(obj) and _check_triple(obj)
def is_triple(obj: _mo.MathObject) -> bool:
"""Return ``True`` if ``obj`` is a `triple`."""
return _relations.is_member(obj) and _check_triple(obj)
def is_triple(obj: _mo.MathObject) -> bool:
"""Return ``True`` if ``obj`` is a valid `triple`, ``False`` if not."""
# noinspection PyTypeChecker
return _relations.is_member(obj) and _check_triple(obj)
