Types equipped with order relations NB: See CONTRIBUTING.md for an introduction to HB concepts and commands. This files defines types equipped with order relations.

How to use orders in MathComp?

Use one of the following modules implementing different theories (all located in the module Order): Order.LTheory: partially ordered types and lattices excluding complement and totality related theorems Order.CTheory: complemented lattices including Order.LTheory Order.TTheory: totally ordered types including Order.LTheory Order.Theory: ordered types including all of the above theory modules To access the definitions, notations, and the theory from, say, "Order.Xyz", insert "Import Order.Xyz." at the top of your scripts. You can also "Import Order.Def." to enjoy shorter notations (e.g., min instead of Order.min, nondecreasing instead of Order.nondecreasing, etc.). In order to reason about abstract orders, notations are accessible by opening the scope "order_scope" bound to the delimiting key "O"; however, when dealing with another notation scope providing order notations for a concrete instance (e.g., "ring_scope"), it is not recommended to open "order_scope" at the same time.

Control of inference (parsing) and printing

One characteristic of ordered types is that one carrier type may have several orders. For example, natural numbers can be totally or partially ordered by the less than or equal relation, the divisibility relation, and their dual relations. Therefore, we need a way to control inference of ordered type instances and printing of generic relations and operations on ordered types. As a rule of thumb, we use the carrier type or its "alias" (named copy) to control inference (using canonical structures), and use a "display" to control the printing of notations. Each generic interface and operation for ordered types has, as its first argument, a "display" of type Order.disp_t. For example, the less than or equal relation has type: Order.le : forall {d : Order.disp_t} {T : porderType d}, rel T, where porderType d is the structure of partially ordered types with display d. (@Order.le dvd_display _ m n) is printed as m %| n because ordered type instances associated to the display dvd_display is intended to represent natural numbers partially ordered by the divisibility relation. We stress that order structure inference can be triggered only from the carrier type (or its alias), but not the display. For example, writing m %| n for m and n of type nat does not trigger an inference of the divisibility relation on natural numbers, which is associated to an alias natdvd for nat; such an inference should be triggered through the use of the corresponding alias, i.e., (m : natdvd) %| n. In other words, displays are merely used to inform the user and the notation mechanism of what the inference did; they are not additional input for the inference. See below for various aliases and their associated displays. NB: algebra/ssrnum.v provides the display ring_display to change the scope of the usual notations to ring_scope. Instantiating d with Disp tt tt or an unknown display will lead to a default display for notations. Alternative notation displays can be defined by : 1. declaring a new opaque definition of type unit. Using the idiom `Fact my_display : Order.disp_t. Proof. exact: Disp tt tt. Qed.` 2. using this symbol to tag canonical porderType structures using `HB.instance Definition _ := isPOrder.Build my_display my_type ...`, 3. declaring notations for the main operations of this library, by setting the first argument of the definition to the display, e.g. `Notation my_syndef_le x y := @Order.le my_display _ x y.` or `Notation "x <=< y" := @Order.lt my_display _ x y (at level ...).` Non overloaded notations will default to the default display. We suggest the user to refer to the example of natdvd below as a guideline example to add their own displays.

Interfaces

We provide the following interfaces for types equipped with an order: porderType d == the type of partially ordered types The HB class is called POrder. bPOrderType d == porderType with a bottom element (\bot) The HB class is called BPOrder. tPOrderType d == porderType with a top element (\top) The HB class is called TPOrder. tbPOrderType d == porderType with both a top and a bottom The HB class is called TBPOrder. meetSemilatticeType d == the type of meet semilattices The HB class is called MeetSemilattice. bMeetSemilatticeType d == meetSemilatticeType with a bottom element The HB class is called BMeetSemilattice. tMeetSemilatticeType d == meetSemilatticeType with a top element The HB class is called TMeetSemilattice. tbMeetSemilatticeType d == meetSemilatticeType with both a top and a bottom The HB class is called TBMeetSemilattice. joinSemilatticeType d == the type of join semilattices The HB class is called JoinSemilattice. bJoinSemilatticeType d == joinSemilatticeType with a bottom element The HB class is called BJoinSemilattice. tJoinSemilatticeType d == joinSemilatticeType with a top element The HB class is called TJoinSemilattice. tbJoinSemilatticeType d == joinSemilatticeType with both a top and a bottom The HB class is called TBJoinSemilattice. latticeType d == the type of lattices The HB class is called Lattice. bLatticeType d == latticeType with a bottom element The HB class is called BLattice. tLatticeType d == latticeType with a top element The HB class is called TLattice. tbLatticeType d == latticeType with both a top and a bottom The HB class is called TBLattice. distrLatticeType d == the type of distributive lattices The HB class is called DistrLattice. bDistrLatticeType d == distrLatticeType with a bottom element The HB class is called BDistrLattice. tDistrLatticeType d == distrLatticeType with a top element The HB class is called TDistrLattice. tbDistrLatticeType d == distrLatticeType with both a top and a bottom The HB class is called TBDistrLattice. orderType d == the type of totally ordered types The HB class is called Total. bOrderType d == orderType with a bottom element The HB class is called BTotal. tOrderType d == orderType with a top element The HB class is called TTotal. tbOrderType d == orderType with both a top and a bottom The HB class is called TBTotal. cDistrLatticeType d == the type of relatively complemented distributive lattices, where each interval [a, b] is equipped with a complement operation The HB class is called CDistrLattice. cbDistrLatticeType d == the type of sectionally complemented distributive lattices, equipped with a bottom, a relative complement operation, and a difference operation, i.e., a complement operation for each interval of the form [\bot, b] The HB class is called CBDistrLattice. ctDistrLatticeType d == the type of dually sectionally complemented distributive lattices, equipped with a top, a relative complement operation, and a dual difference operation, i.e. a complement operation for each interval of the form [a, \top] The HB class is called CTDistrLattice. ctbDistrLatticeType d == the type of complemented distributive lattices, equipped with top, bottom, difference, dual difference, and complement The HB class is called CTBDistrLattice. finPOrderType d == the type of partially ordered finite types The HB class is called FinPOrder. finBPOrderType d == finPOrderType with a bottom element The HB class is called FinBPOrder. finTPOrderType d == finPOrderType with a top element The HB class is called FinTPOrder. finTBPOrderType d == finPOrderType with both a top and a bottom The HB class is called FinTBPOrder. finMeetSemilatticeType d == the type of finite meet semilattice types The HB class is called FinMeetSemilattice. finBMeetSemilatticeType d == finMeetSemilatticeType with a bottom element Note that finTMeetSemilatticeType is just finTBLatticeType. The HB class is called FinBMeetSemilattice. finJoinSemilatticeType d == the type of finite join semilattice types The HB class is called FinJoinSemilattice. finTJoinSemilatticeType d == finJoinSemilatticeType with a top element Note that finBJoinSemilatticeType is just finTBLatticeType. The HB class is called FinTJoinSemilattice. finLatticeType d == the type of finite lattices The HB class is called FinLattice. finTBLatticeType d == the type of nonempty finite lattices The HB class is called FinTBLattice. finDistrLatticeType d == the type of finite distributive lattices The HB class is called FinDistrLattice. finTBDistrLatticeType d == the type of nonempty finite distributive lattices The HB class is called FinTBDistrLattice. finOrderType d == the type of totally ordered finite types The HB class is called FinTotal. finTBOrderType d == the type of nonempty totally ordered finite types The HB class is called FinTBTotal. finCDistrLatticeType d == the type of finite relatively complemented distributive lattices The HB class is called FinCDistrLattice. finCTBDistrLatticeType d == the type of finite complemented distributive lattices The HB class is called FinCTBDistrLattice. and their joins with subType: subPOrder d T P d' == join of porderType d' and subType (P : pred T) such that val is monotonic The HB class is called SubPOrder. meetSubLattice d T P d' == join of latticeType d' and subType (P : pred T) such that val is monotonic and a morphism for meet The HB class is called MeetSubLattice. joinSubLattice d T P d' == join of latticeType d' and subType (P : pred T) such that val is monotonic and a morphism for join The HB class is called JoinSubLattice. subLattice d T P d' == join of JoinSubLattice and MeetSubLattice The HB class is called SubLattice. bJoinSubLattice d T P d' == join of JoinSubLattice and BLattice such that val is a morphism for \bot The HB class is called BJoinSubLattice. tMeetSubLattice d T P d' == join of MeetSubLattice and TLattice such that val is a morphism for \top The HB class is called TMeetSubLattice. bSubLattice d T P d' == join of SubLattice and BLattice such that val is a morphism for \bot The HB class is called BSubLattice. tSubLattice d T P d' == join of SubLattice and TLattice such that val is a morphism for \top The HB class is called BSubLattice. subOrder d T P d' == join of orderType d' and subLatticeType d T P d' The HB class is called SubOrder. subPOrderLattice d T P d' == join of SubPOrder and Lattice The HB class is called SubPOrderLattice. subPOrderBLattice d T P d' == join of SubPOrder and BLattice The HB class is called SubPOrderBLattice. subPOrderTLattice d T P d' == join of SubPOrder and TLattice The HB class is called SubPOrderTLattice. subPOrderTBLattice d T P d' == join of SubPOrder and TBLattice The HB class is called SubPOrderTBLattice. meetSubBLattice d T P d' == join of MeetSubLattice and BLattice The HB class is called MeetSubBLattice. meetSubTLattice d T P d' == join of MeetSubLattice and TLattice The HB class is called MeetSubTLattice. meetSubTBLattice d T P d' == join of MeetSubLattice and TBLattice The HB class is called MeetSubTBLattice. joinSubBLattice d T P d' == join of JoinSubLattice and BLattice The HB class is called JoinSubBLattice. joinSubTLattice d T P d' == join of JoinSubLattice and TLattice The HB class is called JoinSubTLattice. joinSubTBLattice d T P d' == join of JoinSubLattice and TBLattice The HB class is called JoinSubTBLattice. subBLattice d T P d' == join of SubLattice and BLattice The HB class is called SubBLattice. subTLattice d T P d' == join of SubLattice and TLattice The HB class is called SubTLattice. subTBLattice d T P d' == join of SubLattice and TBLattice The HB class is called SubTBLattice. bJoinSubTLattice d T P d' == join of BJoinSubLattice and TBLattice The HB class is called BJoinSubTLattice. tMeetSubBLattice d T P d' == join of TMeetSubLattice and TBLattice The HB class is called TMeetSubBLattice. bSubTLattice d T P d' == join of BSubLattice and TBLattice The HB class is called BSubTLattice. tSubBLattice d T P d' == join of TSubLattice and TBLattice The HB class is called TSubBLattice. tbSubBLattice d T P d' == join of BSubLattice and TSubLattice The HB class is called TBSubLattice. Morphisms between the above structures: OrderMorphism.type d T d' T' == nondecreasing function between two porder := {omorphism T -> T'} MeetLatticeMorphism.type d T d' T', JoinLatticeMorphism.type d T d' T', LatticeMorphism.type d T d' T' == nondecreasing function between two lattices which are morphism for meet, join, and meet/join respectively BLatticeMorphism.type d T d' T' := {blmorphism T -> T'}, TLatticeMorphism.type d T d' T' := {tlmorphism T -> T'}, TBLatticeMorphism.type d T d' T' := {tblmorphism T -> T'} == nondecreasing function between two lattices with bottom/top which are morphism for bottom/top Closedness predicates for the algebraic structures: meetLatticeClosed d T == predicate closed under meet on T : latticeType d The HB class is MeetLatticeClosed. joinLatticeClosed d T == predicate closed under join on T : latticeType d The HB class is JoinLatticeClosed. latticeClosed d T == predicate closed under meet and join The HB class is JoinLatticeClosed. bLatticeClosed d T == predicate that contains bottom The HB class is BLatticeClosed. tLatticeClosed d T == predicate that contains top The HB class is TLatticeClosed. tbLatticeClosed d T == predicate that contains top and bottom the HB class ie TBLatticeClosed. bJoinLatticeClosed d T == predicate that contains bottom and is closed under join The HB class is BJoinLatticeClosed. tMeetLatticeClosed d T == predicate that contains top and is closed under meet The HB class is TMeetLatticeClosed.

Useful lemmas:

On orderType, leP, ltP, and ltgtP are the three main lemmas for case analysis. On porderType, one may use comparableP, comparable_leP, comparable_ltP, and comparable_ltgtP, which are the four main lemmas for case analysis.

Order relations and operations:

In general, an overloaded relation or operation on ordered types takes the following arguments: 1. a display d of type Order.disp_t, 2. an instance T of the minimal structure it operates on, and 3. operands. Here is the exhaustive list of all such operations together with their default notation (defined in order_scope unless specified otherwise). For T of type porderType d, x and y of type T, and C of type bool: x <= y := @Order.le d T x y <-> x is less than or equal to y. x < y := @Order.lt d T x y <-> x is less than y, i.e., (y != x) && (x <= y). x >= y := y <= x <-> x is greater than or equal to y. x > y := y < x <-> x is greater than y. x >=< y := @Order.comparable d T x y (:= (x <= y) || (y <= x)) <-> x and y are comparable. x >< y := ~~ x >=< y <-> x and y are incomparable. x <= y ?= iff C := @Order.leif d T x y C (:= (x <= y) * ((x == y) = C)) <-> x is less than y, or equal iff C is true. x < y ?<= if C := @Order.lteif d T x y C (:= if C then x <= y else x < y) <-> x is smaller than y, and strictly if C is false. Order.min x y := if x < y then x else y Order.max x y := if x < y then y else x f \min g == the function x |-> Order.min (f x) (g x); f \min g simplifies on application. f \max g == the function x |-> Order.max (f x) (g x); f \max g simplifies on application. nondecreasing f <-> the function f : T -> T' is nondecreasing, where T and T' are porderType := {homo f : x y / x <= y} Unary (partially applied) versions of order notations: >= y := @Order.le d T y == a predicate characterizing elements greater than or equal to y > y := @Order.lt d T y <= y := @Order.ge d T y < y := @Order.gt d T y >=< y := [pred x | @Order.comparable d T x y] >< y := [pred x | ~~ @Order.comparable d T x y] 0-ary versions of order notations (in function_scope): <=%O := @Order.le d T <%O := @Order.lt d T >=%O := @Order.ge d T >%O := @Order.gt d T >=<%O := @Order.comparable d T <?=%O := @Order.leif d T <?<=%O := @Order.lteif d T

• > These conventions are compatible with Haskell's, where ((< y) x) = (x < y) = ((<) x y), except that we write <%O instead of (<).

For T of type bPOrderType d: \bot := @Order.bottom d T == the bottom element of type T \max_<range> e := \big[Order.max / Order.bottom]_<range> e == iterated max of a preorder with a bottom the possible <range>s are documented in bigop.v For T of type tPOrderType d: \top := @Order.top d T == the top element of type T \min_<range> e := \big[Order.max / Order.top]_<range> e == iterated min of a preorder with a top the possible <range>s are documented in bigop.v For T of type meetSemilatticeType d, and x, y of type T: x `&` y := @Order.meet d T x y == the meet of x and y For T of type joinSemilatticeType d, and x, y of type T: x `|` y := @Order.join d T x y == the join of x and y For T of type tMeetSemilatticeType d: \meet_<range> e := \big[Order.meet / Order.top]_<range> e == iterated meet of a meet-semilattice with a top the possible <range>s are documented in bigop.v For T of type bJoinSemilatticeType d: \join_<range> e := \big[Order.join / Order.bottom]_<range> e == iterated join of a join-semilattice with a bottom the possible <range>s are documented in bigop.v For T of type cDistrLatticeType d, and x, y, z of type T: rcompl x y z == the (relative) complement of z in [x, y] For T of type cbDistrLatticeType d, and x, y of type T: x `\` y := @Order.diff d T x y == the (sectional) complement of y in [\bot, x], i.e., rcompl \bot x y For T of type ctDistrLatticeType d, and x, y of type T: codiff x y == the (dual sectional) complement of y in [x, \top], i.e., rcompl x \top y For T of type ctbDistrLatticeType d, and x of type T: ~` x := @Order.compl d T x == the complement of x in [\bot, \top], i.e., rcompl \bot \top x For porderType we provide the following operations: [arg min_(i < i0 | P) M] == a value i : T minimizing M : R, subject to the condition P (i may appear in P and M), and provided P holds for i0. [arg max_(i > i0 | P) M] == a value i maximizing M subject to P and provided P holds for i0. [arg min_(i < i0 in A) M] == an i \in A minimizing M if i0 \in A. [arg max_(i > i0 in A) M] == an i \in A maximizing M if i0 \in A. [arg min_(i < i0) M] == an i : T minimizing M, given i0 : T. [arg max_(i > i0) M] == an i : T maximizing M, given i0 : T. with head symbols Order.arg_min and Order.arg_max The user may use extremumP or extremum_inP to eliminate them.

• > patterns for contextual rewriting: leLHS := (X in (X <= _)%O)%pattern leRHS := (X in (_ <= X)%O)%pattern ltLHS := (X in (X < _)%O)%pattern ltRHS := (X in (_ < X)%O)%pattern

We provide aliases for various types and their displays: natdvd := nat (associated with display dvd_display) == an alias for nat which is canonically ordered using divisibility predicate dvdn Notation %|, %<|, gcd, lcm are used instead of <=, <, meet and join. T^d := dual T, where dual is a new definition for (fun T => T) (associated with dual_display d where d is a display) == an alias for T, such that if T is canonically ordered, then T^d is canonically ordered with the dual order, and displayed with an extra ^d in the notation, i.e., <=^d, <^d, >=<^d, ><^d, `&`^d, `|`^d are used and displayed instead of <=, <, >=<, ><, `&`, `|` T *prod[d] T' := T * T' == an alias for the cartesian product such that, if T and T' are canonically ordered, then T *prod[d] T' is canonically ordered in product order, i.e., (x1, x2) <= (y1, y2) = (x1 <= y1) && (x2 <= y2), and displayed in display d T *p T' := T *prod[prod_display d d' ] T' where d and d' are the displays of T and T', respectively, and prod_display adds an extra ^p to all notations T *lexi[d] T' := T * T' == an alias for the cartesian product such that, if T and T' are canonically ordered, then T *lexi[d] T' is canonically ordered in lexicographic order, i.e., (x1, x2) <= (y1, y2) = (x1 <= y1) && ((x1 >= y1) ==> (x2 <= y2)) and (x1, x2) < (y1, y2) = (x1 <= y1) && ((x1 >= y1) ==> (x2 < y2)) and displayed in display d T *l T' := T *lexi[lexi_display d d' ] T' where d and d' are the displays of T and T', respectively, and lexi_display adds an extra ^l to all notations seqprod_with d T := seq T == an alias for seq, such that if T is canonically ordered, then seqprod_with d T is canonically ordered in product order, i.e., [:: x1, .., xn] <= [y1, .., yn] = (x1 <= y1) && ... && (xn <= yn) and displayed in display d n.-tupleprod[d] T == same with n.tuple T seqprod T := seqprod_with (seqprod_display d) T where d is the display of T, and seqprod_display adds an extra ^sp to all notations n.-tupleprod T := n.-tuple[seqprod_display d] T where d is the display of T seqlexi_with d T := seq T == an alias for seq, such that if T is canonically ordered, then seqprod_with d T is canonically ordered in lexicographic order, i.e., [:: x1, .., xn] <= [y1, .., yn] = (x1 <= x2) && ((x1 >= y1) ==> ((x2 <= y2) && ...)) and displayed in display d n.-tuplelexi[d] T == same with n.tuple T seqlexi T := lexiprod_with (seqlexi_display d) T where d is the display of T, and seqlexi_display adds an extra ^sl to all notations n.-tuplelexi T := n.-tuple[seqlexi_display d] T where d is the display of T {subset[d] T} := {set T} == an alias for set which is canonically ordered by the subset order and displayed in display d {subset T} := {subset[subset_display] T} The following notations are provided to build substructures: [SubChoice_isSubPOrder of U by <: with disp] == [SubChoice_isSubPOrder of U by <: ] == porderType mixin for a subType whose base type is a porderType [SubPOrder_isSubLattice of U by <: with disp] == [SubPOrder_isSubLattice of U by <: ] == [SubChoice_isSubLattice of U by <: with disp] == [SubChoice_isSubLattice of U by <: ] == latticeType mixin for a subType whose base type is a latticeType and whose predicate is a latticeClosed [SubPOrder_isBSubLattice of U by <: with disp] == [SubPOrder_isBSubLattice of U by <: ] == [SubChoice_isBSubLattice of U by <: with disp] == [SubChoice_isBSubLattice of U by <: ] == blatticeType mixin for a subType whose base type is a blatticeType and whose predicate is both a latticeClosed and a bLatticeClosed [SubPOrder_isTSubLattice of U by <: with disp] == [SubPOrder_isTSubLattice of U by <: ] == [SubChoice_isTSubLattice of U by <: with disp] == [SubChoice_isTSubLattice of U by <: ] == tlatticeType mixin for a subType whose base type is a tlatticeType and whose predicate is both a latticeClosed and a tLatticeClosed [SubPOrder_isTBSubLattice of U by <: with disp] == [SubPOrder_isTBSubLattice of U by <: ] == [SubChoice_isTBSubLattice of U by <: with disp] == [SubChoice_isTBSubLattice of U by <: ] == tblatticeType mixin for a subType whose base type is a tblatticeType and whose predicate is both a latticeClosed and a tbLatticeClosed [SubLattice_isSubOrder of U by <: with disp] == [SubLattice_isSubOrder of U by <: ] == [SubPOrder_isSubOrder of U by <: with disp] == [SubPOrder_isSubOrder of U by <: ] == [SubChoice_isSubOrder of U by <: with disp] == [SubChoice_isSubOrder of U by <: ] == orderType mixin for a subType whose base type is an orderType [POrder of U by <: ] == porderType mixin for a subType whose base type is a porderType [Order of U by <: ] == orderType mixin for a subType whose base type is an orderType We provide expected instances of ordered types for bool, nat (for leq and and dvdn), 'I_n, 'I_n.+1 (with a top and bottom), nat for dvdn, T *prod[disp] T', T *lexi[disp] T', {t : T & T' x} (with lexicographic ordering), seqprod_with d T (using product order), seqlexi_with d T (with lexicographic ordering), n.-tupleprod[disp] (using product order), n.-tuplelexi[d] T (with lexicographic ordering), on {subset[disp] T} (using subset order) and all possible finite type instances. (Use `HB.about type` to discover the instances on type.) In order to get a canonical order on prod, seq, tuple or set, one may import modules DefaultProdOrder or DefaultProdLexiOrder, DefaultSeqProdOrder or DefaultSeqLexiOrder, DefaultTupleProdOrder or DefaultTupleLexiOrder, and DefaultSetSubsetOrder. We also provide specialized versions of some theorems from path.v. We provide Order.enum_val, Order.enum_rank, and Order.enum_rank_in, which are monotonic variations of enum_val, enum_rank, and enum_rank_in whenever the type is porderType, and their monotonicity is provided if this order is total. The theory is in the module Order (Order.enum_valK, Order.enum_rank_inK, etc) but Order.Enum can be imported to shorten these. We provide an opaque monotonous bijection tagnat.sig / tagnat.rank between the finite types {i : 'I_n & 'I_(p_ i)} and 'I_(\sum_i p_ i): tagnat.sig : 'I_(\sum_i p_ i) -> {i : 'I_n & 'I_(p_ i)} tagnat.rank : {i : 'I_n & 'I_(p_ i)} -> 'I_(\sum_i p_ i) tagnat.sig1 : 'I_(\sum_i p_ i) -> 'I_n tagnat.sig2 : forall p : 'I_(\sum_i p_ i), 'I_(p_ (tagnat.sig1 p)) tagnat.Rank : forall i, 'I_(p_ i) -> 'I_(\sum_i p_ i) Acknowledgments: This file is based on prior work by D. Dreyer, G. Gonthier, A. Nanevski, P-Y Strub, B. Ziliani

Reserved notations for bottom/top elements

Reserved notations for lattice operations

Reserved notations for dual order

Reserved notations for product ordering of prod

Reserved notations for product ordering of seq

Reserved notations for lexicographic ordering of prod

Reserved notations for lexicographic ordering of seq

Reserved notations for divisibility

Reserved notations for iterative meet and join