The base hierarchy of algebraic structures NB: See CONTRIBUTING.md for an introduction to HB concepts and commands. Reference: Francois Garillot, Georges Gonthier, Assia Mahboubi, Laurence Rideau, Packaging mathematical structures, TPHOLs 2009 This file defines the following algebraic structures: nmodType == additive abelian monoid The HB class is called Nmodule. zmodType == additive abelian group (Nmodule with an opposite) The HB class is called Zmodule. semiRingType == non-commutative semi rings (NModule with a multiplication) The HB class is called SemiRing. comSemiRingType == commutative semi rings The HB class is called ComSemiRing. ringType == non-commutative rings (semi rings with an opposite) The HB class is called Ring. comRingType == commutative rings The HB class is called ComRing. lmodType R == module with left multiplication by external scalars in the ring R The HB class is called Lmodule. lalgType R == left algebra, ring with scaling that associates on the left The HB class is called Lalgebra. algType R == ring with scaling that associates both left and right The HB class is called Algebra. comAlgType R == commutative algType The HB class is called ComAlgebra. unitRingType == Rings whose units have computable inverses The HB class is called UnitRing. comUnitRingType == commutative UnitRing The HB class is called ComUnitRing. unitAlgType R == algebra with computable inverses The HB class is called UnitAlgebra. comUnitAlgType R == commutative UnitAlgebra The HB class is called ComUnitAlgebra. idomainType == integral, commutative, ring with partial inverses The HB class is called IntegralDomain. fieldType == commutative fields The HB class is called Field. decFieldType == fields with a decidable first order theory The HB class is called DecidableField. closedFieldType == algebraically closed fields The HB class is called ClosedField. and their joins with subType: subNmodType V P == join of nmodType and subType (P : pred V) such that val is semi_additive The HB class is called SubNmodule. subZmodType V P == join of zmodType and subType (P : pred V) such that val is additive The HB class is called SubZmodule. subSemiRingType R P == join of semiRingType and subType (P : pred R) such that val is a semiring morphism The HB class is called SubSemiRing. subComSemiRingType R P == join of comSemiRingType and subType (P : pred R) such that val is a morphism The HB class is called SubComSemiRing. subRingType R P == join of ringType and subType (P : pred R) such that val is a morphism The HB class is called SubRing. subComRingType R P == join of comRingType and subType (P : pred R) such that val is a morphism The HB class is called SubComRing. subLmodType R V P == join of lmodType and subType (P : pred V) such that val is scalable The HB class is called SubLmodule. subLalgType R V P == join of lalgType and subType (P : pred V) such that val is linear The HB class is called SubLalgebra. subAlgType R V P == join of algType and subType (P : pred V) such that val is linear The HB class is called SubAlgebra. subUnitRingType R P == join of unitRingType and subType (P : pred R) such that val is a ring morphism The HB class is called SubUnitRing. subComUnitRingType R P == join of comUnitRingType and subType (P : pred R) such that val is a ring morphism The HB class is called SubComUnitRing. subIdomainType R P == join of idomainType and subType (P : pred R) such that val is a ring morphism The HB class is called SubIntegralDomain. subField R P == join of fieldType and subType (P : pred R) such that val is a ring morphism The HB class is called SubField. Morphisms between the above structures (see below for details): {additive U -> V} == semi additive (resp. additive) functions between nmodType (resp. zmodType) instances U and V. The HB class is called Additive. {rmorphism R -> S} == semi ring (resp. ring) morphism between semiRingType (resp. ringType) instances R and S. The HB class is called RMorphism. {linear U -> V | s} == linear functions of type U -> V, where U is a left module over a ring R, V is a Z-module, and s is a scaling operator of type R -> V -> V. The HB class is called Linear. {lrmorphism A -> B | s} == linear ring morphisms of type A -> B, where A is a left algebra over a ring R, B is a ring, and s is a scaling operator of type R -> B -> B. The HB class is called LRMorphism.

• > The scaling operator s above should be one of *:%R, *%R, or a combination nu \; *:%R or nu \; *%R with a ring morphism nu; otherwise some of the theory (e.g., the linearZ rule) will not apply. To enable the overloading of the scaling operator, we use the following structures: GRing.Scale.law R V == scaling morphisms of type R -> V -> V The HB class is called Scale.Law.

Closedness predicates for the algebraic structures: opprClosed V == predicate closed under opposite on V : zmodType The HB class is called OppClosed. addrClosed V == predicate closed under addition on V : nmodType The HB class is called AddClosed. zmodClosed V == predicate closed under opposite and addition on V The HB class is called ZmodClosed. mulr2Closed R == predicate closed under multiplication on R : semiRingType The HB class is called Mul2Closed. mulrClosed R == predicate closed under multiplication and for 1 The HB class is called MulClosed. smulClosed R == predicate closed under multiplication and for -1 The HB class is called SmulClosed. semiring2Closed R == predicate closed under addition and multiplication The HB class is called Semiring2Closed. semiringClosed R == predicate closed under semiring operations The HB class is called SemiringClosed. subringClosed R == predicate closed under ring operations The HB class is called SubringClosed. divClosed R == predicate closed under division The HB class is called DivClosed. sdivClosed R == predicate closed under division and opposite The HB class is called SdivClosed. submodClosed R == predicate closed under lmodType operations The HB class is called SubmodClosed. subalgClosed R == predicate closed under lalgType operations The HB class is called SubalgClosed. divringClosed R == predicate closed under unitRing operations The HB class is called DivringClosed. divalgClosed R S == predicate closed under (S : unitAlg R) operations The HB class is called DivalgClosed. Canonical properties of the algebraic structures:

Nmodule (additive abelian monoids):

0 == the zero (additive identity) of a Nmodule x + y == the sum of x and y (in a Nmodule) x *+ n == n times x, with n in nat (non-negative), i.e., x + (x + .. (x + x)..) (n terms); x *+ 1 is thus convertible to x, and x *+ 2 to x + x \sum_<range> e == iterated sum for a Zmodule (cf bigop.v) e`_i == nth 0 e i, when e : seq M and M has a zmodType structure support f == 0.-support f, i.e., [pred x | f x != 0] addr_closed S <-> collective predicate S is closed under finite sums (0 and x + y in S, for x, y in S) [SubChoice_isSubNmodule of U by <: ] == nmodType mixin for a subType whose base type is a nmodType and whose predicate's is a nmodClosed

Zmodule (additive abelian groups):

• x == the opposite (additive inverse) of x

x - y == the difference of x and y; this is only notation for x + (- y) x *- n == notation for - (x *+ n), the opposite of x *+ n oppr_closed S <-> collective predicate S is closed under opposite zmod_closed S <-> collective predicate S is closed under zmodType operations (0 and x - y in S, for x, y in S) This property coerces to oppr_pred and addr_pred. [SubChoice_isSubZmodule of U by <: ] == zmodType mixin for a subType whose base type is a zmodType and whose predicate's is a zmodClosed

SemiRing (non-commutative semirings):

R^c == the converse (semi)ring for R: R^c is convertible to R but when R has a canonical (semi)RingType structure R^c has the converse one: if x y : R^c, then x * y = (y : R) * (x : R) 1 == the multiplicative identity element of a semiring n%:R == the semiring image of an n in nat; this is just notation for 1 *+ n, so 1%:R is convertible to 1 and 2%:R to 1 + 1 <number> == <number>%:R with <number> a sequence of digits x * y == the semiring product of x and y \prod_<range> e == iterated product for a semiring (cf bigop.v) x ^+ n == x to the nth power with n in nat (non-negative), i.e., x * (x * .. (x * x)..) (n factors); x ^+ 1 is thus convertible to x, and x ^+ 2 to x * x GRing.comm x y <-> x and y commute, i.e., x * y = y * x GRing.lreg x <-> x if left-regular, i.e., *%R x is injective GRing.rreg x <-> x if right-regular, i.e., *%R^~ x is injective [char R] == the characteristic of R, defined as the set of prime numbers p such that p%:R = 0 in R The set [char R] has at most one element, and is implemented as a pred_nat collective predicate (see prime.v); thus the statement p \in [char R] can be read as `R has characteristic p', while [char R] =i pred0 means `R has characteristic 0' when R is a field. Frobenius_aut chRp == the Frobenius automorphism mapping x in R to x ^+ p, where chRp : p \in [char R] is a proof that R has (non-zero) characteristic p mulr_closed S <-> collective predicate S is closed under finite products (1 and x * y in S for x, y in S) semiring_closed S <-> collective predicate S is closed under semiring operations (0, 1, x + y and x * y in S) [SubNmodule_isSubSemiRing of R by <: ] == [SubChoice_isSubSemiRing of R by <: ] == semiRingType mixin for a subType whose base type is a semiRingType and whose predicate's is a semiringClosed

Ring (non-commutative rings):

GRing.sign R b := (-1) ^+ b in R : ringType, with b : bool This is a parsing-only helper notation, to be used for defining more specific instances. smulr_closed S <-> collective predicate S is closed under products and opposite (-1 and x * y in S for x, y in S) subring_closed S <-> collective predicate S is closed under ring operations (1, x - y and x * y in S) [SubZmodule_isSubRing of R by <: ] == [SubChoice_isSubRing of R by <: ] == ringType mixin for a subType whose base type is a ringType and whose predicate's is a subringClosed

ComSemiRing (commutative SemiRings):

[SubNmodule_isSubComSemiRing of R by <: ] == [SubChoice_isSubComSemiRing of R by <: ] == comSemiRingType mixin for a subType whose base type is a comSemiRingType and whose predicate's is a semiringClosed

ComRing (commutative Rings):

[SubZmodule_isSubComRing of R by <: ] == [SubChoice_isSubComRing of R by <: ] == comRingType mixin for a subType whose base type is a comRingType and whose predicate's is a subringClosed

UnitRing (Rings whose units have computable inverses):

x \is a GRing.unit <=> x is a unit (i.e., has an inverse) x^-1 == the ring inverse of x, if x is a unit, else x x / y == x divided by y (notation for x * y^-1) x ^- n := notation for (x ^+ n)^-1, the inverse of x ^+ n invr_closed S <-> collective predicate S is closed under inverse divr_closed S <-> collective predicate S is closed under division (1 and x / y in S) sdivr_closed S <-> collective predicate S is closed under division and opposite (-1 and x / y in S, for x, y in S) divring_closed S <-> collective predicate S is closed under unitRing operations (1, x - y and x / y in S) [SubRing_isSubUnitRing of R by <: ] == [SubChoice_isSubUnitRing of R by <: ] == unitRingType mixin for a subType whose base type is a unitRingType and whose predicate's is a divringClosed and whose ring structure is compatible with the base type's

ComUnitRing (commutative rings with computable inverses):

[SubChoice_isSubComUnitRing of R by <: ] == comUnitRingType mixin for a subType whose base type is a comUnitRingType and whose predicate's is a divringClosed and whose ring structure is compatible with the base type's

IntegralDomain (integral, commutative, ring with partial inverses):

[SubComUnitRing_isSubIntegralDomain R by <: ] == [SubChoice_isSubIntegralDomain R by <: ] == mixin axiom for a idomain subType

Field (commutative fields):

GRing.Field.axiom inv == field axiom: x != 0 -> inv x * x = 1 for all x This is equivalent to the property above, but does not require a unitRingType as inv is an explicit argument. [SubIntegralDomain_isSubField of R by <: ] == mixin axiom for a field subType

DecidableField (fields with a decidable first order theory):

GRing.term R == the type of formal expressions in a unit ring R with formal variables 'X_k, k : nat, and manifest constants x%:T, x : R The notation of all the ring operations is redefined for terms, in scope %T. GRing.formula R == the type of first order formulas over R; the %T scope binds the logical connectives /\, \/, ~, ==>, ==, and != to formulae; GRing.True/False and GRing.Bool b denote constant formulae, and quantifiers are written 'forall/'exists 'X_k, f GRing.Unit x tests for ring units GRing.If p_f t_f e_f emulates if-then-else GRing.Pick p_f t_f e_f emulates fintype.pick foldr GRing.Exists/Forall q_f xs can be used to write iterated quantifiers GRing.eval e t == the value of term t with valuation e : seq R (e maps 'X_i to e`_i) GRing.same_env e1 e2 <-> environments e1 and e2 are extensionally equal GRing.qf_form f == f is quantifier-free GRing.holds e f == the intuitionistic CiC interpretation of the formula f holds with valuation e GRing.qf_eval e f == the value (in bool) of a quantifier-free f GRing.sat e f == valuation e satisfies f (only in a decField) GRing.sol n f == a sequence e of size n such that e satisfies f, if one exists, or [:: ] if there is no such e 'exists 'X_i, u1 == 0 /\ ... /\ u_m == 0 /\ v1 != 0 ... /\ v_n != 0

Lmodule (module with left multiplication by external scalars).

a *: v == v scaled by a, when v is in an Lmodule V and a is in the scalar Ring of V scaler_closed S <-> collective predicate S is closed under scaling linear_closed S <-> collective predicate S is closed under linear combinations (a *: u + v in S when u, v in S) submod_closed S <-> collective predicate S is closed under lmodType operations (0 and a *: u + v in S) [SubZmodule_isSubLmodule of V by <: ] == [SubChoice_isSubLmodule of V by <: ] == mixin axiom for a subType of an lmodType

Lalgebra (left algebra, ring with scaling that associates on the left):

R^o == the regular algebra of R: R^o is convertible to R, but when R has a ringType structure then R^o extends it to an lalgType structure by letting R act on itself: if x : R and y : R^o then x *: y = x * (y : R) k%:A == the image of the scalar k in an L-algebra; this is simply notation for k *: 1 subalg_closed S <-> collective predicate S is closed under lalgType operations (1, a *: u + v and u * v in S) [SubRing_SubLmodule_isSubLalgebra of V by <: ] == [SubChoice_isSubLalgebra of V by <: ] == mixin axiom for a subType of an lalgType

Algebra (ring with scaling that associates both left and right):

[SubLalgebra_isSubAlgebra of V by <: ] == [SubChoice_isSubAlgebra of V by <: ] == mixin axiom for a subType of an algType

UnitAlgebra (algebra with computable inverses):

divalg_closed S <-> collective predicate S is closed under all unitAlgType operations (1, a *: u + v and u / v are in S fo u, v in S) In addition to this structure hierarchy, we also develop a separate, parallel hierarchy for morphisms linking these structures:

Additive (semi additive or additive functions):

semi_additive f <-> f of type U -> V is semi additive, i.e., f maps the Nmodule structure of U to that of V, 0 to 0 and + to + := (f 0 = 0) * {morph f : x y / x + y} additive f <-> f of type U -> V is additive, i.e., f maps the Zmodule structure of U to that of V, 0 to 0,

• to - and + to + (equivalently, binary - to -)

:= {morph f : u v / u - v} {additive U -> V} == the interface type for a Structure (keyed on a function f : U -> V) that encapsulates the semi_additive property; both U and V must have canonical nmodType instances When both U and V have zmodType instances, it is an additive function. := GRing.Additive.type U V

RMorphism (semiring or ring morphisms):

multiplicative f <-> f of type R -> S is multiplicative, i.e., f maps 1 and * in R to 1 and * in S, respectively R and S must have canonical semiRingType instances {rmorphism R -> S} == the interface type for semiring morphisms; both R and S must have semiRingType instances When both R and S have ringType instances, it is a ring morphism. := GRing.RMorphism.type R S

• > If R and S are UnitRings the f also maps units to units and inverses of units to inverses; if R is a field then f is a field isomorphism between R and its image.
• > Additive properties (raddf_suffix, see below) are duplicated and specialised for RMorphism (as rmorph_suffix). This allows more precise rewriting and cleaner chaining: although raddf lemmas will recognize RMorphism functions, the converse will not hold (we cannot add reverse inheritance rules because of incomplete backtracking in the Canonical Projection unification), so one would have to insert a /= every time one switched from additive to multiplicative rules.

Linear (linear functions):

scalable_for s f <-> f of type U -> V is scalable for the scaling operator s of type R -> V -> V, i.e., f morphs a *: _ to s a _; R, U, and V must be a ringType, an lmodType R, and a zmodType, respectively. := forall a, {morph f : u / a *: u >-> s a u} scalable f <-> f of type U -> V is scalable, i.e., f morphs scaling on U to scaling on V, a *: _ to a *: _; U and V must be an lmodType R for the same ringType R. := scalable_for *:%R f linear_for s f <-> f of type U -> V is linear for s of type R -> V -> V, i.e., f (a *: u + v) = s a (f u) + f v; R, U, and V must be a ringType, an lmodType R, and a zmodType, respectively. linear f <-> f of type U -> V is linear, i.e., f (f *: u + v) = a *: f u + f v; U and V must be lmodType R for the same ringType R. := linear_for *:%R f scalar f <-> f of type U -> R is a scalar function, i.e., f (a *: u + v) = a * f u + f v; R and U must be a ringType and an lmodType R, respectively. := linear_for *%R f {linear U -> V | s} == the interface type for functions linear for the scaling operator s of type R -> V -> V, i.e., a structure that encapsulates two properties semi_additive f and scalable_for s f for functions f : U -> V; R, U, and V must be a ringType, an lmodType R, and a zmodType, respectively := @GRing.Linear.type R U V s {linear U -> V} == the interface type for linear functions, of type U -> V where both U and V must be lmodType R for the same ringType R := {linear U -> V | *:%R} {scalar U} == the interface type for scalar functions of type U -> R where U must be an lmodType R := {linear U -> V | *%R} (a *: u)%Rlin == transient forms that simplify to a *: u, a * u, (a * u)%Rlin nu a *: u, and nu a * u, respectively, and are (a *:^nu u)%Rlin created by rewriting with the linearZ lemma (a *^nu u)%Rlin The forms allows the RHS of linearZ to be matched reliably, using the GRing.Scale.law structure.

• > Similarly to Ring morphisms, additive properties are specialized for linear functions.
• > Although {scalar U} is convertible to {linear U -> R^o}, it does not actually use R^o, so that rewriting preserves the canonical structure of the range of scalar functions.
• > The generic linearZ lemma uses a set of bespoke interface structures to ensure that both left-to-right and right-to-left rewriting work even in the presence of scaling functions that simplify non-trivially (e.g., idfun \; *%R). Because most of the canonical instances and projections are coercions the machinery will be mostly invisible (with only the {linear ...} structure and %Rlin notations showing), but users should beware that in (a *: f u)%Rlin, a actually occurs in the f u subterm.
• > The simpler linear_LR, or more specialized linearZZ and scalarZ rules should be used instead of linearZ if there are complexity issues, as well as for explicit forward and backward application, as the main parameter of linearZ is a proper sub-interface of {linear fUV | s}.

LRMorphism (linear ring morphisms, i.e., algebra morphisms):

{lrmorphism A -> B | s} == the interface type for ring morphisms linear for the scaling operator s of type R -> B -> B, i.e., the join of ring morphisms {rmorphism A -> B} and linear functions {linear A -> B | s}; R, A, and B must be a ringType, an lalgType R, and a ringType, respectively := @GRing.LRMorphism.type R A B s {lrmorphism A -> B} == the interface type for algebra morphisms, where A and B must be lalgType R for the same ringType R := {lrmorphism A -> B | *:%R}

• > Linear and rmorphism properties do not need to be specialized for as we supply inheritance join instances in both directions.

Finally we supply some helper notation for morphisms: x^f == the image of x under some morphism This notation is only reserved (not defined) here; it is bound locally in sections where some morphism is used heavily (e.g., the container morphism in the parametricity sections of poly and matrix, or the Frobenius section here) \0 == the constant null function, which has a canonical linear structure, and simplifies on application (see ssrfun.v) f \+ g == the additive composition of f and g, i.e., the function x |-> f x + g x; f \+ g is canonically linear when f and g are, and simplifies on application (see ssrfun.v) f \- g == the function x |-> f x - g x, canonically linear when f and g are, and simplifies on application \- g == the function x |-> - f x, canonically linear when f is, and simplifies on application k \*: f == the function x |-> k *: f x, which is canonically linear when f is and simplifies on application (this is a shorter alternative to *:%R k \o f) GRing.in_alg A == the ring morphism that injects R into A, where A has an lalgType R structure; GRing.in_alg A k simplifies to k%:A a \*o f == the function x |-> a * f x, canonically linear when f is and its codomain is an algType and which simplifies on application a \o* f == the function x |-> f x * a, canonically linear when f is and its codomain is an lalgType and which simplifies on application f \* g == the function x |-> f x * g x; f \* g simplifies on application The Lemmas about these structures are contained in both the GRing module and in the submodule GRing.Theory, which can be imported when unqualified access to the theory is needed (GRing.Theory also allows the unqualified use of additive, linear, Linear, etc). The main GRing module should NOT be imported. Notations are defined in scope ring_scope (delimiter %R), except term and formula notations, which are in term_scope (delimiter %T). This library also extends the conventional suffixes described in library ssrbool.v with the following: 0 -- ring 0, as in addr0 : x + 0 = x 1 -- ring 1, as in mulr1 : x * 1 = x D -- ring addition, as in linearD : f (u + v) = f u + f v B -- ring subtraction, as in opprB : - (x - y) = y - x M -- ring multiplication, as in invfM : (x * y)^-1 = x^-1 * y^-1 Mn -- ring by nat multiplication, as in raddfMn : f (x *+ n) = f x *+ n N -- ring opposite, as in mulNr : (- x) * y = - (x * y) V -- ring inverse, as in mulVr : x^-1 * x = 1 X -- ring exponentiation, as in rmorphXn : f (x ^+ n) = f x ^+ n Z -- (left) module scaling, as in linearZ : f (a *: v) = s *: f v The operator suffixes D, B, M and X are also used for the corresponding operations on nat, as in natrX : (m ^ n)%:R = m%:R ^+ n. For the binary power operator, a trailing "n" suffix is used to indicate the operator suffix applies to the left-hand ring argument, as in expr1n : 1 ^+ n = 1 vs. expr1 : x ^+ 1 = x.

Patch for recurring Coq parser bug: Coq seg faults when a level 200 notation is used as a pattern.

The ``field'' characteristic; the definition, and many of the theorems, has to apply to rings as well; indeed, we need the Frobenius automorphism results for a non commutative ring in the proof of Gorenstein 2.6.3.

Converse ring tag.