Library mathcomp.ssreflect.order

This files defines types equipped with order relations. Use one of the following modules implementing different theories: 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. Notations are accessible by opening the scope "order_scope" bound to the delimiting key "O". We provide the following structures of ordered types porderType d == the type of partially ordered types latticeType d == the type of non-distributive lattices bLatticeType d == latticeType with a bottom element tbLatticeType d == latticeType with both a top and a bottom distrLatticeType d == the type of distributive lattices bDistrLatticeType d == distrLatticeType with a bottom element tbDistrLatticeType d == distrLatticeType with both a top and a bottom cbDistrLatticeType d == the type of sectionally complemented distributive lattices (lattices with bottom and a difference operation) ctbDistrLatticeType d == the type of complemented distributive lattices (lattices with top, bottom, difference, and complement) orderType d == the type of totally ordered types finPOrderType d == the type of partially ordered finite types finLatticeType d == the type of nonempty finite non-distributive lattices finDistrLatticeType d == the type of nonempty finite distributive lattices finCDistrLatticeType d == the type of nonempty finite complemented distributive lattices finOrderType d == the type of nonempty totally ordered finite types Each generic partial order and lattice operations symbols also has a first argument which is the display, the second which is the minimal structure they operate on and then the operands. Here is the exhaustive list of all such symbols for partial orders and lattices together with their default display (as displayed by Check). We document their meaning in the paragraph after the next. For porderType T @Order.le disp T == <=%O (in fun_scope) @Order.lt disp T == <%O (in fun_scope) @Order.comparable disp T == >=<%O (in fun_scope) @Order.ge disp T == >=%O (in fun_scope) @Order.gt disp T == >%O (in fun_scope) @Order.leif disp T == <?=%O (in fun_scope) For distrLatticeType T @Order.meet disp T x y == x `&` y (in order_scope) @Order.join disp T x y == x `|` y (in order_scope) For bDistrLatticeType T @Order.bottom disp T == 0 (in order_scope) For tbDistrLatticeType T @Order.top disp T == 1 (in order_scope) For cbDistrLatticeType T @Order.sub disp T x y == x `|` y (in order_scope) For ctbDistrLatticeType T @Order.compl disp T x == ~` x (in order_scope) This first argument named either d, disp or display, of type unit, configures the printing of notations. Instantiating d with tt or an unknown key will lead to a default display for notations, i.e. we have: 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 <-> x and y are comparable (:= (x <= y) || (y <= x)). x >< y <-> x and y are incomparable (:= ~~ x >=< y). For x, y of type T, where T is canonically a distrLatticeType 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 bDistrLatticeType d: 0 == the bottom element. \join<range> e == iterated join of a lattice with a bottom. In a type T, where T is canonically a tbDistrLatticeType d: 1 == 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 [0, x]. For x of type T, where T is canonically a ctbDistrLatticeType d: ~` x == the complement of x in [0, 1]. 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 (<). Alternative notation displays can be defined by : 1. declaring a new opaque definition of type unit. Using the idiom `Lemma my_display : unit. Proof. exact: tt. Qed.` 2. using this symbol to tag canonical porderType structures using `Canonical my_porderType := POrderType my_display my_type my_mixin`, 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. 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, the first one is a *documented example* 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 Beware that canonical structure inference will not try to find the copy of the structures that fits the display one mentioned, but will rather determine which canonical structure and display to use depending on the copy of the type one provided. In this sense they are merely displays to inform the user of what the inference did, rather than additional input for the inference. Existing displays are either dual_display d (where d is a display), dvd_display (both explained above), ring_display (from algebra/ssrnum 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. The default display is tt and users can define their own as explained above. 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. In order to build the above structures, one must provide the appropriate mixin to the following structure constructors. The list of possible mixins is indicated after each constructor. Each mixin is documented in the next paragraph. POrderType disp T pord_mixin == builds a porderType from a canonical choiceType instance of T where pord_mixin can be of types lePOrderMixin, ltPOrderMixin, meetJoinMixin, leOrderMixin, or ltOrderMixin or computed using PcanPOrderMixin or CanPOrderMixin. disp is a display as explained above LatticeType T lat_mixin == builds a latticeType from a porderType where lat_mixin can be of types latticeMixin, meetJoinMixin, leOrderMixin, ltOrderMixin, totalPOrderMixin or computed using IsoLatticeMixin. DistrLatticeType T lat_mixin == builds a distrLatticeType from a porderType where lat_mixin can be of types distrLatticeMixin, meetJoinMixin, leOrderMixin leOrderMixin, ltOrderMixin, totalPOrderMixin, or totalLatticeMixin or computed using IsoLatticeMixin. BLatticeType T bot_mixin == builds a bDistrLatticeType from a distrLatticeType and a bottom element TBLatticeType T top_mixin == builds a tbDistrLatticeType from a bDistrLatticeType and a top element CBLatticeType T sub_mixin == builds a cbDistrLatticeType from a bDistrLatticeType and a difference operation CTBLatticeType T compl_mixin == builds a ctbDistrLatticeType from a tbDistrLatticeType and a complement operation OrderType T ord_mixin == builds an orderType from a distrLatticeType where ord_mixin can be of types leOrderMixin, ltOrderMixin, totalPOrderMixin, totalLatticeMixin, or totalOrderMixin or computed using MonoTotalMixin. Additionally:

• [porderType of _ ] ... notations are available to recover structures on "copies" of the types, as in eqtype, choicetype, ssralg...
• [finPOrderType of _ ] ... notations to compute joins between finite types and ordered types

List of possible mixins (a.k.a. factories):

• lePOrderMixin == on a choiceType, takes le, lt, reflexivity, antisymmetry and transitivity of le. (can build: porderType)
• ltPOrderMixin == on a choiceType, takes le, lt, irreflexivity and transitivity of lt. (can build: porderType)
• meetJoinMixin == on a choiceType, takes le, lt, meet, join, commutativity and associativity of meet and join idempotence of meet and some De Morgan laws (can build: porderType, latticeType, distrLatticeType)
• leOrderMixin == on a choiceType, takes le, lt, meet, join antisymmetry, transitivity and totality of le. (can build: porderType, latticeType, distrLatticeType, orderType)
• ltOrderMixin == on a choiceType, takes le, lt, irreflexivity, transitivity and totality of lt. (can build: porderType, latticeType, distrLatticeType, orderType)
• totalPOrderMixin == on a porderType T, totality of the order of T := total (<=%O : rel T) (can build: latticeType, distrLatticeType, orderType)
• totalLatticeMixin == on a latticeType T, totality of the order of T := total (<=%O : rel T) (can build distrLatticeType, orderType)
• totalOrderMixin == on a distrLatticeType T, totality of the order of T := total (<=%O : rel T) (can build: orderType) NB: the above three mixins are kept separate from each other (even though they are convertible), in order to avoid ambiguous coercion paths.
• distrLatticeMixin == on a latticeType T, takes meet, join commutativity and associativity of meet and join idempotence of meet and some De Morgan laws (can build: distrLatticeType)
• bDistrLatticeMixin, tbDistrLatticeMixin, cbDistrLatticeMixin, ctbDistrLatticeMixin == mixins with one extra operation (respectively bottom, top, relative complement, and total complement)

Additionally:

• [porderMixin of T by <: ] creates a porderMixin by subtyping.
• [totalOrderMixin of T by <: ] creates the associated totalOrderMixin.
• PCanPOrderMixin, CanPOrderMixin create porderMixin from cancellations
• MonoTotalMixin creates a totalPOrderMixin from monotonicity
• IsoLatticeMixin creates a distrLatticeMixin from an ordered structure isomorphism (i.e., cancel f f', cancel f' f, {mono f : x y / x <= y})

List of "big pack" notations:

• DistrLatticeOfChoiceType builds a distrLatticeType from a choiceType and a meetJoinMixin.
• OrderOfChoiceType builds an orderType from a choiceType, and a leOrderMixin or a ltOrderMixin.
• OrderOfPOrder builds an orderType from a porderType and a totalPOrderMixin.
• OrderOfLattice builds an orderType from a latticeType and a totalLatticeMixin.

NB: These big pack notations should be used only to construct instances on the fly, e.g., in the middle of a proof, and should not be used to declare canonical instances. See field/algebraics_fundamentals.v for an example usage. We provide the following canonical instances of ordered types

• all possible structures on bool
• porderType, latticeType, distrLatticeType, orderType and bDistrLatticeType on nat for the leq order
• porderType, latticeType, distrLatticeType, bDistrLatticeType, cbDistrLatticeType, ctbDistrLatticeType on nat for the dvdn order, where meet and join are respectively gcdn and lcmn
• porderType, latticeType, distrLatticeType, orderType, bDistrLatticeType, tbDistrLatticeType, cbDistrLatticeType, ctbDistrLatticeType on T *prod[disp] T' a "copy" of T * T' using product order (and T *p T' its specialization to prod_display)
• porderType, latticeType, distrLatticeType, and orderType, on T *lexi[disp] T' another "copy" of T * T', with lexicographic ordering (and T *l T' its specialization to lexi_display)
• porderType, latticeType, distrLatticeType, and orderType, on {t : T & T' x} with lexicographic ordering
• porderType, latticeType, distrLatticeType, orderType, bDistrLatticeType, cbDistrLatticeType, tbDistrLatticeType, ctbDistrLatticeType on seqprod_with disp T a "copy" of seq T using product order (and seqprod T' its specialization to prod_display)
• porderType, latticeType, distrLatticeType, and orderType, on seqlexi_with disp T another "copy" of seq T, with lexicographic ordering (and seqlexi T its specialization to lexi_display)
• porderType, latticeType, distrLatticeType, orderType, bDistrLatticeType, cbDistrLatticeType, tbDistrLatticeType, ctbDistrLatticeType on n.-tupleprod[disp] a "copy" of n.-tuple T using product order (and n.-tupleprod T its specialization to prod_display)
• porderType, latticeType, distrLatticeType, and orderType, on n.-tuplelexi[d] T another "copy" of n.-tuple T, with lexicographic ordering (and n.-tuplelexi T its specialization to lexi_display)

and all possible finite type instances In order to get a canonical order on prod or seq, one may import modules DefaultProdOrder or DefaultProdLexiOrder, DefaultSeqProdOrder or DefaultSeqLexiOrder, and DefaultTupleProdOrder or DefaultTupleLexiOrder. 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. We also provide specialized versions of some theorems from path.v. This file is based on prior work by D. Dreyer, G. Gonthier, A. Nanevski, P-Y Strub, B. Ziliani

Reserved notation for lattice operations.

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.

STRUCTURES