field

..admonition:: Field

Mathematically a Field is a Commutative Ring all whose non-zero elements have multiplicative inverses.

By convention one != zero, otherwise the algebra consists of just one unique element.

Important

Contract: Field initializer parameters must have

• add closed, commutative and associative on reps

• mult closed, commutative and associative on reps

• one an identity on reps, rep*one == rep == one*rep

• zero an identity on reps, rep+zero == rep == zero+rep

• inv is the mult inverse function on all non-zero reps

• negate function to negate all proper rep values

• invert function to invert all proper rep values

• zero != one (by convention)

class boring_math.abstract_algebra.algebras.field.Field

Bases: CommutativeRing, Generic

Parameters:

• mult – Closed associative function reps.

• add – Closed commutative and associative function reps.

• one – Representation for multiplicative identity.

• zero – Representation for additive identity.

• negate – Function mapping element representation to the representation of corresponding negated element.

• invert – Function mapping non-zero element representations to their multiplicative inverses.

• 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], add: Callable[[H, H], H], one: H, zero: H, negate: Callable[[H], H], invert: Callable[[H], H], narrow: Callable[[H], H] | None = None)

Parameters:

• mult – Closed associative function reps.

• add – Closed commutative and associative function reps.

• one – Representation for multiplicative identity.

• zero – Representation for additive identity.

• negate – Function mapping element representation to the representation of corresponding negated element.

• invert – Function mapping non-zero element representations to their multiplicative inverses.

• narrow – Narrow the rep type, many to one function, like choosing an element from a coset of a group,

__call__(rep: H) → FieldElement

Add the unique element to the field 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.field.FieldElement

Bases: CommutativeRingElement, Generic

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

__str__() → str

Returns:

str(self) = FieldElement<rep>

__pow__(n: int) → Self

Raise the element to the int power of n.

Parameters:

n – The int power to raise the element to.

Returns:

The element (or its inverse) raised to an int power.

Raises:

• ValueError – If algebra is not multiplicative.

• ValueError – If algebra does not have a multiplicative identity element.

• ValueError – If algebra does not have multiplicative inverses.

__truediv__(right: Self) → Self

Divide self by right.

__add__(right: Self) → Self

Add two elements of the same concrete algebra together.

Parameters:

other – Another element within the same algebra.

Returns:

The sum self + other.

Raises:

• ValueError – If self and other are same type but different concrete algebras.

• TypeError – If Addition not defined on the algebra of the elements.

• TypeError – If self and right are different types.

__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

Left multiplication for * operator.

Parameters:

right – Object left should be an element of same concrete algebra or an int.

Returns:

Algebra product, the sum of the element right times, or NotImplemented.

Raises:

• ValueError – If either right not an element of the same concrete algebra or right: int < 0.

• TypeError – Multiplication nor defined on the algebra that self is a member of.

__neg__() → Self

Negate the element.

Returns:

The unique additive inverse element to self.

Raises:

ValueError – If algebra fails to have additive inverses.

__radd__(left: Self) → Self

When left side of addition does not know how to add right side.

Parameters:

other – Left side of the addition.

Returns:

Never returns, otherwise left.__add__(right) would have worked.

Raises:

TypeError – When right side does not know how to add the left side to itself.

__rmul__(left: object) → Self

Right multiplication for * operator.

Parameters:

left – Object left should be an int.

Returns:

The sum of the element left times.

Raises:

TypeError – If object on left does not act on object on right