Closures¶

The galactic.algebras.closure module.

It defines classes for creating closure operators and closed sets.

Closure;
Closed;
MooreFamily.

class Closed(*args, **kwds)¶

The Closed class is used to represent a closed set.

abstract property closure¶

Get the underlying closure operators.

Returns: The closure operator.
Return type: Closure[_E, _T]

equivalence(element: _T) → Iterator[_T]¶

Compute equivalences of the element.

Parameters: element (_T) – The element whose equivalences are requested
Returns: An iterator over the equivalence elements of element
Return type: Iterator[_T]

intersection(*args: Any) → galactic.algebras.lattice.Meetable ¶

Return the intersection of this element and the others.

Parameters: *args (object) – the others elements
Returns: the meet of this element and the others
Return type: Meetable
Raises: TypeError – if one of the other elements is not an instance of this element class.

subsumption(element: _T) → Iterator[_T]¶

Compute subsumed elements of the element.

Parameters: element (_T) – The element whose subsumed elements are requested
Returns: An iterator over the subsumed elements of element
Return type: Iterator[_T]

property support¶

Get the closed set support.

Returns: The closed set support.
Return type: float

supsumption(element: _T) → Iterator[_T]¶

Compute supsumed elements of the element.

Notes

supsumption is a neologism to designate the inverse relation of subsumption.

Parameters: element (_T) – The element whose supsumed elements are requested
Returns: An iterator over the supsumed elements of element
Return type: Iterator[_T]

union(*args: Any) → galactic.algebras.lattice.Joinable ¶

Return the union of this element and the others.

Parameters: *args (object) – the others elements
Returns: the join of this element and the others
Return type: Joinable
Raises: TypeError – if one of the other elements is not an instance of this element class.

class Closure(*args, **kwds)¶

The Closure class is used to represent a closure operator.

The Greek letter \(\phi\) is often used to name a closure operator.

Notes

See https://en.wikipedia.org/wiki/Closure_operator

abstract __call__(elements: Optional[Iterable[_T]] = None) → _E¶

Call this closure on a iterable of elements.

Parameters: elements (Iterable[_T]) – The iterable of elements.
Returns: The closed representation of the object into a row.
Return type: _E

class MooreFamily(closure: galactic.algebras.closure.Closure[_E, _T])¶

A MooreFamily is a lattice of closed sets containing the universe.

Notes

See https://en.wikipedia.org/wiki/Closure_operator

Examples

>>> from galactic.algebras.closure import MooreFamily
>>> from galactic.examples.closure import NumericalClosure, NumericalClosed
>>> elements = {0, 1, 2, 3, 4, 5}
>>> closure = NumericalClosure(elements)
>>> family = MooreFamily[NumericalClosed, int](closure)
>>> list(family.domain)
[<0,5>]
>>> family.extend([closure([0, 1, 3]), closure([2, 5])])
>>> list(family.domain)
[<0,5>, <2,5>, <0,3>, <2,3>]
>>> family.extend([closure([4, 5])])
>>> list(family.domain)
[<0,5>, <2,5>, <0,3>, <4,5>, <2,3>, <>]

__contains__(item: Any) → bool ¶

Get the membership of an element.

Parameters: item – The element whose membership is requested.
Returns: True if the item belongs to the partially ordered set.
Return type: bool

__copy__() → galactic.algebras.lattice.Lattice[_E]¶

Get a copy of the lattice.

The operation is in \(O(j+m)\).

Returns: The copy of this lattice.
Return type: Lattice[_E]

__init__(closure: galactic.algebras.closure.Closure[_E, _T])¶

Initialise a MooreFamily instance.

Parameters: closure (Closure[_E, _T]) – A closure operator.

__iter__() → Iterator[Tuple[_P, _P]]¶

Get an iterator over the elements.

Returns: An iterator over the elements
Return type: Iterator[Tuple[_P, _P]]

property atoms¶

Get the atoms of this lattice.

Returns: The atoms
Return type: AbstractSet[_E]

property bottom¶

Get the bottom elements.

The collection contains only one element, the minimum element.

Returns: The bottom elements.
Return type: AbstractSet[_E]

property closure¶

Get the underlying closure operator.

Returns: The closure operator.
Return type: Closure[_E, _T]

property co_atoms¶

Get the co-atoms of this lattice.

Returns: The co-atoms.
Return type: AbstractSet[_E]

property co_domain¶

Get the co-domain of this lattice.

Returns: The co-domain of this lattice.
Return type: AbstractSet[_E]

property cover¶

Get the covering relation of this lattice.

Returns: The covering relation.
Return type: AbstractReversibleCoveringRelation[_E]

property domain¶

Get the domain of this lattice.

Returns: The domain of this lattice.
Return type: AbstractSet[_E]

extend(iterable: Iterable[_E]) → None ¶

In-place enlarge the lattice with an iterable of elements.

Parameters: iterable (Iterable[_E]) – An iterable of elements

filter(element: _E) → galactic.algebras.lattice.AbstractLattice[_E]¶

Get a filter of a lattice.

Parameters: element (_E) – The lower limit
Returns: The lower bounded lattice.
Return type: AbstractLattice[_E]
Raises: ValueError – If the element does not belong to the poset.

property global_entropy¶

Compute the global entropy of the Moore family.

\[H(L)=\sum_{A\in L}p(A)I(A)=n-\frac{\sum_{A\in L}\kappa(( A,B))\log_2(\kappa(A))}{2^n}\]

Notes

See Information .

Returns: The global entropy.
Return type: float

Examples

>>> from galactic.algebras.closure import MooreFamily
>>> from galactic.examples.closure import NumericalClosure, NumericalClosed
>>> elements = {0, 1, 2, 3, 4, 5}
>>> closure = NumericalClosure(elements)
>>> family = MooreFamily[NumericalClosed, int](closure)
>>> family.extend([closure([1, 2, 3]), closure([2, 3, 4])])
>>> round(family.global_entropy, 3)
1.311

property global_information¶

Compute the global information of the Moore family.

It is equal to the global entropy multiplied by the number of element defined by the closure operator.

\[I(L)=n H(L)\]

Returns: The global information.
Return type: float

Examples

>>> from galactic.algebras.closure import MooreFamily
>>> from galactic.examples.closure import NumericalClosure, NumericalClosed
>>> elements = {0, 1, 2, 3, 4, 5}
>>> closure = NumericalClosure(elements)
>>> family = MooreFamily[NumericalClosed, int](closure)
>>> family.extend([closure([1, 2, 3]), closure([2, 3, 4])])
>>> round(family.global_information, 3)
7.868

property global_logarithmic_stability¶

Compute the global normalized logarithmic stability of the Moore family.

\[\lambda(L)=\sum_{A\in L}p(A)\lambda(A)\]

Returns: The global normalized logarithmic stability.
Return type: float

Examples

>>> from galactic.algebras.closure import MooreFamily
>>> from galactic.examples.closure import NumericalClosure, NumericalClosed
>>> elements = {0, 1, 2, 3, 4, 5}
>>> closure = NumericalClosure(elements)
>>> family = MooreFamily[NumericalClosed, int](closure)
>>> family.extend([closure([1, 2, 3]), closure([2, 3, 4])])
>>> round(family.global_logarithmic_stability, 3)
0.335

property global_stability¶

Compute the global stability of the Moore family.

\[\sigma(L)=\sum_{A\in L}p(A)\sigma(A) =\sum_{A\in L}\frac{\kappa(A)^2}{2^{|A|+n}}\]

Returns: The global stability.
Return type: float

Examples

>>> from galactic.algebras.closure import MooreFamily
>>> from galactic.examples.closure import NumericalClosure, NumericalClosed
>>> elements = {0, 1, 2, 3, 4, 5}
>>> closure = NumericalClosure(elements)
>>> family = MooreFamily[NumericalClosed, int](closure)
>>> family.extend([closure([1, 2, 3]), closure([2, 3, 4])])
>>> round(family.global_stability, 3)
0.703

greatest_join_irreducible(element: _E) → AbstractSet[_E]¶

Get the greatest join irreducible smaller than an element.

Parameters: element (_E) – The element whose greatest join irreducible are requested
Returns: The greatest join irreducible smaller than the element.
Return type: AbstractSet[_E]
Raises: ValueError – If the element does not belong to the lattice.

ideal(element: _E) → galactic.algebras.lattice.AbstractLattice[_E]¶

Get an ideal of a lattice.

Parameters: element (_E) – The upper limit
Returns: The upper bounded lattice.
Return type: AbstractLattice[_E]
Raises: ValueError – If the element does not belong to the poset.

information() → Iterator[Tuple[_E, float]]¶

Get an iterator on elements (\(A\), \(I(A)\)).

\(I(A)\) is the information of \(A\).

\[I(A)=-\log_2(p(A)\]

Returns: An iterator on elements and their information.
Return type: Iterator[Tuple[_E, float]]

Notes

See Information .

Examples

>>> from galactic.algebras.closure import MooreFamily
>>> from galactic.examples.closure import NumericalClosure, NumericalClosed
>>> elements = {0, 1, 2, 3, 4, 5}
>>> closure = NumericalClosure(elements)
>>> family = MooreFamily[NumericalClosed, int](closure)
>>> family.extend([closure([1, 2, 3]), closure([2, 3, 4])])
>>> for element, information in family.information():
...     print(list(element), information)
[2, 3] 4.0
[2, 3, 4] 4.0
[1, 2, 3] 4.0
[1, 2, 3, 4] 4.0
[0, 1, 2, 3, 4, 5] 0.4150374992788439

isdisjoint(other)¶: Return True if two sets have a null intersection.

property join_irreducible¶

Get the join irreducible elements.

Returns: The join irreducible elements
Return type: AbstractSet[_E]

logarithmic_stabilities() → Iterator[Tuple[_E, float]]¶

Get an iterator on (\(A\), \(\lambda(A)\)).

\(\lambda(A)\) is the normalized logarithmic stabilities of \(A\) (the normalized logarithmic stability is always between 0 and 1).

if \(\kappa(A)\) is equal to \(2^{|A|}\), the normalized logarithmic stability is equal to 1.
if \(\kappa(A)\) is equal to \(1\), the normalized logarithmic stability is equal to 0
the special case \(A=\emptyset\) (\(2^{|A|}=\kappa(A)=1\)) gives \(\lambda(\emptyset)=1\) by convention.

\[\begin{split}\begin{eqnarray} \lambda(A) &=&\frac{-\log_2\left(1-\sigma(A)+\frac{1}{2^{|A|}}\right)}{|A|}\\ &=&\frac{-\log_2\left(\frac{2^{|A|}-\kappa(A)+1}{2^{|A|}}\right)}{|A|}\\ &=&\frac{|A|-\log_2\left(2^{|A|}-\kappa(A)+1\right)}{|A|}\\ &=&1-\frac{\log_2\left(2^{|A|}-\kappa(A)+1\right)}{|A|}\\ \lambda(\emptyset) &=&1\\ \end{eqnarray}\end{split}\]