group¶

Group

Mathematically a Group is a Monoid G all of whose elements have multiplicative inverses.

Caution

No assumptions are made whether or not the group is Abelian. See CommunitiveGroup.

Important

Contract: Group initializer parameters must have

mult closed and associative on reps
one an identity on reps, rep*one == rep == one*rep
inv must me idempotent: inv(inv(rep)) == rep

class boring_math.abstract_algebra.algebras.group.Group¶

Bases: Monoid, Generic

Parameters:

mult – Associative function H X H -> H on representations.
one – Representation for multiplicative identity.
invert – Function H -> H mapping element representation to the representation of corresponding inverse element.
narrow – Narrow the rep type, many-to-one function. Like choosing an element from a coset of a group.

__init__(mult: Callable[[H, H], H], one: H, invert: Callable[[H], H], narrow: Callable[[H], H] | None = None)¶

Parameters:

mult – Associative function H X H -> H on representations.
one – Representation for multiplicative identity.
invert – Function H -> H mapping element representation to the representation of corresponding inverse element.
narrow – Narrow the rep type, many-to-one function. Like choosing an element from a coset of a group.

__call__(rep: H) → GroupElement¶

Add the unique element to the group with a with the given, perhaps narrowed, rep.

Parameters:: rep – Representation to add if not already present.
Returns:: The unique element with that representation.

__eq__(right: object) → bool¶

Compare if two algebras are the same concrete algebra.

Parameters:: right – Object being compared to.
Returns:: True only if right is the same concrete algebra. False otherwise.

narrow_rep_type(rep: H) → H¶

Narrow the type with a concrete algebra’s many-to-one type “narrowing” function.

Parameters:: rep – Hashable value of type H.
Returns:: The narrowed representation.

class boring_math.abstract_algebra.algebras.group.GroupElement¶

Bases: MonoidElement, Generic

__init__(rep: H, algebra: Group[H]) → None¶

__str__() → str¶

Returns:: str(self) = GroupElement<rep>

__pow__(n: int) → Self¶

Raise the element to the power of n.

Parameters:

n – The int power to raise the element to.

Returns:

The element (or its inverse) raised to the integer``n`` power.

Raises:

ValueError – If element’s algebra
ValueError – If self and other are same type but different concrete groups.
ValueError – If algebra fails to have an identity or elements not invertible.

__call__() → H¶

Warning

A trade off is being made in favor of efficiency over encapsulation. An actual reference to the wrapped rep is returned to eliminate the overhead of a copy.

Returns:: The narrowed representation wrapped within the element.

__eq__(right: object) → bool¶

Compares if two elements, not necessarily in the same concrete algebra, contain equal representations of the same hashable type.

Warning

Any sort of difference in rep narrowing is not taken into consideration.

Parameters:: right – Object to be compared with.
Returns:: True if both are elements and the reps compare as equal and are of the same invariant type.

__mul__(right: object) → Self¶

Multiply two elements of the same concrete algebra together.

Parameters:: right – An element within the same concrete algebra or a right action.
Returns:: The product self * right otherwise NotImplemented.
Raises:: ValueError – If self and right are same type but different concrete algebras.

__rmul__(left: object) → Self¶

When left side of multiplication does not know how to multiply right side.

Parameters:: left – Left side of the multiplication.
Returns:: Never returns, otherwise left.__mul__(right) would have worked.
Raises:: TypeError – When multiplying on left by an int.