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. 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.

Interfaces

Before providing the list of interfaces, a word is necessary about "displays". Each generic partial order has, as a first argument, a display to control the printing of notations. For example, when m and n are of type natdvd (an alias of nat), (Order.le m n) is displayed m %| n; natdvd is associated to the display dvd_display. Instantiating d with tt or an unknown display will lead to a default display for notations. See below for more details about displays. 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. latticeType d == the type of non-distributive lattices The HB class is called Lattice. bPOrderType d == partial order with a bottom element The HB class is called BPOrder. bLatticeType d == latticeType with a bottom element The HB class is called BLattice. tPOrderType d == partial order with a top element The HB class is called TPOrder. tbPOrderType d == partial order with a top and a bottom elements The HB class is called TBPOrder. 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. tbDistrLatticeType d == distrLatticeType with both a top and a bottom The HB class is called TBDistrLattice. cbDistrLatticeType d == the type of sectionally complemented distributive lattices (lattices with bottom and a difference operation) The HB class is called CBDistrLattice. ctbDistrLatticeType d == the type of complemented distributive lattices (lattices with top, bottom, difference, and complement) The HB class is called CTBDistrLattice. orderType d == the type of totally ordered types The HB class is called Total. finPOrderType d == the type of partially ordered finite types The HB class is called FinPOrder. finLatticeType d == the type of nonempty finite non-distributive lattices The HB class is called FinLattice. finDistrLatticeType d == the type of nonempty finite distributive lattices The HB class is called FinDistrLattice. finCDistrLatticeType d == the type of nonempty finite complemented distributive lattices The HB class is called FinCDistrLattice. finOrderType d == the type of nonempty totally ordered finite types The HB class is called FinTotal. 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' == monotonic function between the two porder := {omorphism T -> T'} MeetLatticeMorphism.type d T d' T', JoinLatticeMorphism.type d T d' T', LatticeMorphism.type d T d' T' == monotonic 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'} == monotonic 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 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. For x, y of type T, where T is canonically a porderType d: x <= y <-> x is less than or equal to y x < y <-> x is less than y (:= (y != x) && (x <= y)) min x y <-> if x < y then x else y max x y <-> if x < y then y else x x >= y <-> x is greater than or equal to y (:= y <= x) x > y <-> x is greater than y (:= y < x) x <= y ?= iff C <-> x is less than y, or equal iff C is true x < y ?<= if C <-> x is smaller than y, and strictly if C is false x >=< y <-> x and y are comparable (:= (x <= y) || (y <= x)) x >< y <-> x and y are incomparable (:= ~~ x >=< y) 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 For x, y of type T, where T is canonically a latticeType d: x `&` y == the meet of x and y x `|` y == the join of x and y In a type T, where T is canonically a bLatticeType d: \bot == the bottom element \join_<range> e == iterated join of a lattice with a bottom In a type T, where T is canonically a tbLatticeType d: \top == the top element \meet_<range> e == iterated meet of a lattice with a top For x, y of type T, where T is canonically a cbDistrLatticeType d: x `\` y == the (sectional) complement of y in [\bot, x] For x of type T, where T is canonically a ctbDistrLatticeType d: ~` x == the complement of x in [\bot, \top] There are three distinct uses of the symbols <, <=, >, >=, _ <= _ ?= iff _, >=<, and >< in the default display: they can be 0-ary, unary (prefix), and binary (infix). 0. <%O, <=%O, >%O, >=%O, <?=%O, >=<%O, and ><%O stand respectively for lt, le, gt, ge, leif (_ <= _ ?= iff _), comparable, and incomparable. 1. (< x), (<= x), (> x), (>= x), (>=< x), and (>< x) stand respectively for (>%O x), (>=%O x), (<%O x), (<=%O x), (>=<%O x), and (><%O x). So (< x) is a predicate characterizing elements smaller than x. 2. (x < y), (x <= y), ... mean what they are expected to. These conventions are compatible with Haskell's, where ((< y) x) = (x < y) = ((<) x y), except that we write <%O instead of (<). Like each generic partial order, lattice operations symbols also have a first argument which is the display (ranged over by d of type unit), the second which is the minimal structure they operate on and then the operands. Here is the exhaustive l list of all such symbols for partial orders and lattices together with their default printed notation (as displayed by Check). For porderType T (in function_scope): <=%O == @Order.le d T <%O == @Order.lt d T >=<%O == @Order.comparable d T >=%O == @Order.ge d T >%O == @Order.gt d T <?=%O == @Order.leif d T <?<=%O == @Order.lteif d T For latticeType T (in order_scope): x `&` y == @Order.meet d T x y x `|` y == @Order.join d T x y For bLatticeType T (in order_scope): \bot == @Order.bottom d T For tLatticeType T (in order_scope): \top == @Order.top d T For cbDistrLatticeType T (in order_scope): x `|` y == @Order.sub d T x y For ctbDistrLatticeType T (in order_scope): ~` x == @Order.compl d T 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

One may use displays either for convenience or to disambiguate between different structures defined on "copies" of a type (as explained below). We provide the following "copies" of types: natdvd := nat == a "copy" of 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) == a "copy" of 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' == a "copy" of 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] T' where prod_display adds an extra ^p to all notations T *lexi[d] T' := T * T' == a "copy" of 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] T' where lexi_display adds an extra ^l to all notations seqprod_with d T := seq T == a "copy" of 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 prod_display T n.-tupleprod T := n.-tuple[prod_display] T seqlexi_with d T := seq T == a "copy" of 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 lexi_display T n.-tuplelexi T := n.-tuple[lexi_display] T {subset[d] T} := {set T} == a "copy" of set which is canonically ordered by the subset order and displayed in display d {subset T} := {subset[subset_display] T} Existing displays are either dual_display d (where d is a display), dvd_display, ring_display (from algebra/ssrnum.v to change the scope of the usual notations to ring_scope). We also provide lexi_display and prod_display for lexicographic and product order respectively. Beware of the asymmetry of canonical structure inference. Canonical structure inference makes it possible to infer the display associated to a type (or a named copy of a type) from the name. However, it does not help finding the named copy when the display is provided. In this sense 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. Alternative notation displays can be defined by : 1. declaring a new opaque definition of type unit. Using the idiom `Fact my_display : unit. Proof. exact: 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 (further explained below) as guide line example to add their own displays. 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's 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's 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's 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's 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 monotonous 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 notation for lattice operations.

Reserved notation for lattices with bottom/top elements.

Notations for dual partial and total order

Reserved notation for dual lattice operations.

Reserved notations for product ordering of prod or seq

Reserved notation for dual lattice operations.

Reserved notations for lexicographic ordering of prod or seq

Reserved notations for divisibility

Reserved notation for dual lattice operations.

TODO: print nice error message when keyed type is not provided

Bind Scope order_scope with POrder.sort.

Lifted min/max operations.

HB.mixin Record POrder_isJoinSemiLattice d (T : indexed Type) of POrder d T := { join : T -> T -> T; joinC : commutative join; joinA : associative join; le_defU : forall x y, (x <= y) = (join x y == y); }. # [short(type="joinSemiLatticeType") ] HB.structure Definition JoinSemiLattice d := { T of POrder_isJoinSemiLattice d T & POrder d T }. HB.mixin Record POrder_isMeetSemiLattice d (T : indexed Type) of POrder d T := { meet : T -> T -> T; meetC : commutative meet; meetA : associative meet; le_def : forall x y, (x <= y) = (meet x y == x); }. # [short(type="meetSemiLatticeType") ] HB.structure Definition MeetSemiLattice d := { T of POrder_isMeetSemiLattice d T & POrder d T }.

HB.builders Context d T of POrder_isLattice d T. Let le_defU : forall x y, (x <= y) = (join x y == y). Proof. Admitted. HB.instance Definition _ := @POrder_isMeetSemiLattice.Build d T meet meetC meetA le_def. HB.instance Definition _ := @POrder_isJoinSemiLattice.Build d T join joinC joinA le_defU. HB.end.