algebra.ring

A Boolean ring is a ring whose multiplication is idempotent, that is a⋅a = a for all elements ''a''. This property also implies a+a = 0 for all ''a'', and a⋅b = b⋅a (commutativity of multiplication).

Every Boolean ring is equivalent to a Boolean algebra. See algebra.lattice.BoolFromBoolRing for details.

A Boolean rng is a rng whose multiplication is idempotent, that is a⋅a = a for all elements ''a''. This property also implies a+a = 0 for all ''a'', and a⋅b = b⋅a (commutativity of multiplication).

Every BoolRng is equivalent to algebra.lattice.GenBool. See algebra.lattice.GenBoolFromBoolRng for details.

CommutativeRig is a Rig that is commutative under multiplication.

CommutativeRing is a Ring that is commutative under multiplication.

CommutativeRng is a Rng that is commutative under multiplication.

CommutativeSemifield is a Semifield that is commutative under multiplication.

CommutativeSemiring is a Semiring that is commutative under multiplication.

EuclideanRing implements a Euclidean domain.

The formal definition says that every euclidean domain A has (at least one) euclidean function f: A -> N (the natural numbers) where:

(for every x and non-zero y) x = yq + r, and r = 0 or f(r) < f(y).

This generalizes the Euclidean division of integers, where f represents a measure of length (or absolute value), and the previous equation represents finding the quotient and remainder of x and y. So:

quot(x, y) = q mod(x, y) = r

GCDRing implements a GCD ring.

For two elements x and y in a GCD ring, we can choose two elements d and m such that:

d = gcd(x, y) m = lcm(x, y)

d * m = x * y

Additionally, we require:

gcd(0, 0) = 0 lcm(x, 0) = lcm(0, x) = 0

and commutativity:

gcd(x, y) = gcd(y, x) lcm(x, y) = lcm(y, x)

Rig consists of:

• a commutative monoid for addition (+)
• a monoid for multiplication (*)

Alternately, a Rig can be thought of as a ring without multiplicative or additive inverses (or as a semiring with a multiplicative identity).

Mnemonic: "Rig is a Ring without 'N'egation."

Ring consists of:

• a commutative group for addition (+)
• a monoid for multiplication (*)

Additionally, multiplication must distribute over addition.

Ring implements some methods (for example fromInt) in terms of other more fundamental methods (zero, one and plus). Where possible, these methods should be overridden by more efficient implementations.

Rng (pronounced "Rung") consists of:

• a commutative group for addition (+)
• a semigroup for multiplication (*)

Alternately, a Rng can be thought of as a ring without a multiplicative identity (or as a semiring with an additive inverse).

Mnemonic: "Rng is a Ring without multiplicative 'I'dentity."

Semifield consists of:

• a commutative monoid for addition (+)
• a group for multiplication (*)

Alternately, a Semifield can be thought of as a DivisionRing without an additive inverse.

Semiring consists of:

• a commutative monoid for addition (+)
• a semigroup for multiplication (*)

Alternately, a Semiring can be thought of as a ring without a multiplicative identity or an additive inverse.

A Semiring with an additive inverse (-) is a Rng. A Semiring with a multiplicative identity (1) is a Rig. A Semiring with both of those is a Ring.

A trait that expresses the existence of signs and absolute values on linearly ordered additive commutative monoids (i.e. types with addition and a zero).

The following laws holds:

(1) if a <= b then a + c <= b + c (linear order), (2) signum(x) = -1 if x < 0, signum(x) = 1 if x > 0, signum(x) = 0 otherwise,

Negative elements only appear when the scalar is taken from a additive abelian group. Then:

(3) abs(x) = -x if x < 0, or x otherwise,

Laws (1) and (2) lead to the triange inequality:

(4) abs(a + b) <= abs(a) + abs(b)

Signed should never be extended in implementations, rather the Signed.forAdditiveCommutativeMonoid and subtraits.

It's better to have the Signed hierarchy separate from the Ring/Order hierarchy, so that we do not end up with duplicate implicits.

Division and modulus for computer scientists taken from https://www.microsoft.com/en-us/research/wp-content/uploads/2016/02/divmodnote-letter.pdf

For two numbers x (dividend) and y (divisor) on an ordered ring with y != 0, there exists a pair of numbers q (quotient) and r (remainder) such that these laws are satisfied:

(1) q is an integer (2) x = y * q + r (division rule) (3) |r| < |y|, (4t) r = 0 or sign(r) = sign(x), (4f) r = 0 or sign(r) = sign(y).

where sign is the sign function, and the absolute value function |x| is defined as |x| = x if x >=0, and |x| = -x otherwise.

We define functions tmod and tquot such that: q = tquot(x, y) and r = tmod(x, y) obey rule (4t), (which truncates effectively towards zero) and functions fmod and fquot such that: q = fquot(x, y) and r = fmod(x, y) obey rule (4f) (which floors the quotient and effectively rounds towards negative infinity).

Law (4t) corresponds to ISO C99 and Haskell's quot/rem. Law (4f) is described by Knuth and used by Haskell, and fmod corresponds to the REM function of the IEEE floating-point standard.