fact
stringlengths 8
1.54k
| type
stringclasses 19
values | library
stringclasses 8
values | imports
listlengths 1
10
| filename
stringclasses 98
values | symbolic_name
stringlengths 1
42
| docstring
stringclasses 1
value |
|---|---|---|---|---|---|---|
lteif_andbx y : {morph lteif x y : p q / p && q}.
Proof.
case=> [][] /=.
- by rewrite andbb.
- by rewrite lt_le_def andbA andbb.
- by rewrite andbC lt_le_def andbA andbb.
- by rewrite andbb.
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
lteif_andb
| |
lteif_implyC1 C2 x y : C1 ==> C2 -> x < y ?<= if C1 -> x < y ?<= if C2.
Proof. by case: C1 C2 => [][] //= _ /ltW. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
lteif_imply
| |
lteifWC x y : x < y ?<= if C -> x <= y.
Proof. by case: C => // /ltW. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
lteifW
| |
ltrW_lteifC x y : x < y -> x < y ?<= if C.
Proof. by case: C => // /ltW. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
ltrW_lteif
| |
minEltx y : min x y = if x < y then x else y. Proof. by []. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
minElt
| |
maxEltx y : max x y = if x < y then y else x. Proof. by []. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
maxElt
| |
minxx: idempotent_op (min : T -> T -> T).
Proof. by rewrite /min => x; rewrite ltxx. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
minxx
| |
maxxx: idempotent_op (max : T -> T -> T).
Proof. by rewrite /max => x; rewrite ltxx. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
maxxx
| |
min_minKxx y : min (min x y) y = min x y.
Proof. by rewrite !(fun_if, if_arg) ltxx/=; case: (x < y). Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
min_minKx
| |
min_minxKx y : min x (min x y) = min x y.
Proof. by rewrite !(fun_if, if_arg) ltxx/=; case: (x < y). Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
min_minxK
| |
max_maxKxx y : max (max x y) y = max x y.
Proof. by rewrite !(fun_if, if_arg) ltxx/=; case: (x < y). Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
max_maxKx
| |
max_maxxKx y : max x (max x y) = max x y.
Proof. by rewrite !(fun_if, if_arg) ltxx/=; case: (x < y). Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
max_maxxK
| |
comparable_minlz : {in >=< z &, forall x y, min x y >=< z}.
Proof. by move=> x y cmp_xz cmp_yz; rewrite /min; case: ifP. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_minl
| |
comparable_minrz : {in >=<%O z &, forall x y, z >=< min x y}.
Proof. by move=> x y cmp_xz cmp_yz; rewrite /min; case: ifP. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_minr
| |
comparable_maxlz : {in >=< z &, forall x y, max x y >=< z}.
Proof. by move=> x y cmp_xz cmp_yz; rewrite /max; case: ifP. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_maxl
| |
comparable_maxrz : {in >=<%O z &, forall x y, z >=< max x y}.
Proof. by move=> x y cmp_xz cmp_yz; rewrite /max; case: ifP. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_maxr
| |
comparable_le_min: (z <= min x y) = (z <= x) && (z <= y).
Proof.
move: cmp_xy; rewrite /min /comparable lt_le_def.
case/boolP: (x <= y) => xy/=; case/boolP: (y <= x) => yx//= _.
- by rewrite andbC; case/boolP: (z <= y) => zy //=; apply/esym/(le_trans zy).
- by case/boolP: (z <= x) => zx //=; apply/esym/(le_trans zx).
- by rewrite andbC; case/boolP: (z <= y) => zy //=; apply/esym/(le_trans zy).
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_le_min
| |
comparable_ge_min: (min x y <= z) = (x <= z) || (y <= z).
Proof.
move: cmp_xy; rewrite /min /comparable lt_le_def.
case/boolP: (x <= y) => xy/=; case/boolP: (y <= x) => yx//= _.
- rewrite orbC; case/boolP: (y <= z) => //= /negP yz.
by apply/esym/negP => /(le_trans yx).
- by case/boolP: (x <= z) => //= /negP xz; apply/esym/negP => /(le_trans xy).
- rewrite orbC; case/boolP: (y <= z) => //= /negP yz.
by apply/esym/negP => /(le_trans yx).
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_ge_min
| |
comparable_lt_min: (z < min x y) = (z < x) && (z < y).
Proof.
move: cmp_xy; rewrite /min /comparable !lt_le_def.
case/boolP: (x <= y) => xy/=; case/boolP: (y <= x) => yx//= _.
- rewrite -!lt_le_def; case/boolP: (z < x) => //= /negP zx.
by apply/negP => zy; apply/zx/(lt_le_trans zy).
- rewrite -!lt_le_def; case/boolP: (z < x) => //= zx; apply/esym/(lt_trans zx).
by rewrite lt_le_def xy yx.
- rewrite -!lt_le_def andbC; case/boolP: (z < y) => //= zy; apply/esym/(lt_trans zy).
by rewrite lt_le_def xy yx.
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_lt_min
| |
comparable_gt_min: (min x y < z) = (x < z) || (y < z).
Proof.
move: cmp_xy; rewrite /min /comparable !lt_le_def.
case/boolP: (x <= y) => xy/=; case/boolP: (y <= x) => yx//= _.
- rewrite -!lt_le_def orbC; case/boolP: (y < z) => //= /negP yz.
by apply/esym/negP => xz; apply/yz/(le_lt_trans yx).
- rewrite -!lt_le_def; case/boolP: (x < z) => //= /negP xz.
by apply/esym/negP => yz; apply/xz/(le_lt_trans xy).
- rewrite -!lt_le_def orbC; case/boolP: (y < z) => //= /negP yz.
by apply/esym/negP => xz; apply/yz/(le_lt_trans yx).
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_gt_min
| |
comparable_le_max: (z <= max x y) = (z <= x) || (z <= y).
Proof.
move: cmp_xy; rewrite /max /comparable lt_le_def.
case/boolP: (x <= y) => xy/=; case/boolP: (y <= x) => yx//= _.
- case/boolP: (z <= x) => //= /negP zx.
by apply/esym/negP => zy; apply/zx/(le_trans zy).
- rewrite orbC; case/boolP: (z <= y) => //= /negP zy.
by apply/esym/negP => zx; apply/zy/(le_trans zx).
- case/boolP: (z <= x) => //= /negP zx.
by apply/esym/negP => zy; apply/zx/(le_trans zy).
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_le_max
| |
comparable_ge_max: (max x y <= z) = (x <= z) && (y <= z).
Proof.
move: cmp_xy; rewrite /max /comparable lt_le_def.
case/boolP: (x <= y) => xy/=; case/boolP: (y <= x) => yx//= _.
- case/boolP: (x <= z) => //= xz.
by apply/esym/(le_trans yx).
- rewrite andbC; case/boolP: (y <= z) => //= yz.
by apply/esym/(le_trans xy).
- case/boolP: (x <= z) => //= xz.
by apply/esym/(le_trans yx).
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_ge_max
| |
comparable_lt_max: (z < max x y) = (z < x) || (z < y).
Proof.
move: cmp_xy; rewrite /max /comparable !lt_le_def.
case/boolP: (x <= y) => xy/=; case/boolP: (y <= x) => yx//= _.
- rewrite -!lt_le_def; case/boolP: (z < x) => //= /negP zx.
by apply/esym/negP => zy; apply/zx/(lt_le_trans zy).
- rewrite -!lt_le_def orbC; case/boolP: (z < y) => //= /negP zy.
by apply/esym/negP => zx; apply/zy/(lt_le_trans zx).
- rewrite -!lt_le_def; case/boolP: (z < x) => //= /negP zx.
by apply/esym/negP => zy; apply/zx/(lt_le_trans zy).
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_lt_max
| |
comparable_gt_max: (max x y < z) = (x < z) && (y < z).
Proof.
move: cmp_xy; rewrite /max /comparable !lt_le_def.
case/boolP: (x <= y) => xy/=; case/boolP: (y <= x) => yx//= _.
- rewrite -!lt_le_def; case/boolP: (x < z) => //= xz.
by apply/esym/(le_lt_trans yx).
- rewrite -!lt_le_def andbC; case/boolP: (y < z) => //= yz.
by apply/esym/(le_lt_trans xy).
- rewrite -!lt_le_def; case/boolP: (x < z) => //= xz.
by apply/esym/(le_lt_trans yx).
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_gt_max
| |
comparable_minxK: max (min x y) y = y.
Proof. by rewrite !(fun_if, if_arg) ltxx/=; case: (x < y). Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_minxK
| |
comparable_minKx: max x (min x y) = x.
Proof. by rewrite !(fun_if, if_arg) ltxx/=; case: (x < y). Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_minKx
| |
comparable_maxxK: min (max x y) y = y.
Proof. by rewrite !(fun_if, if_arg) ltxx/=; case: (x < y). Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_maxxK
| |
comparable_maxKx: min x (max x y) = x.
Proof. by rewrite !(fun_if, if_arg) ltxx/=; case: (x < y). Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_maxKx
| |
comparable_lteif_minrC :
(z < min x y ?<= if C) = (z < x ?<= if C) && (z < y ?<= if C).
Proof. by case: C; rewrite /= (comparable_le_min, comparable_lt_min). Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_lteif_minr
| |
comparable_lteif_minlC :
(min x y < z ?<= if C) = (x < z ?<= if C) || (y < z ?<= if C).
Proof. by case: C; rewrite /= (comparable_ge_min, comparable_gt_min). Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_lteif_minl
| |
comparable_lteif_maxrC :
(z < max x y ?<= if C) = (z < x ?<= if C) || (z < y ?<= if C).
Proof. by case: C; rewrite /= (comparable_le_max, comparable_lt_max). Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_lteif_maxr
| |
comparable_lteif_maxlC :
(max x y < z ?<= if C) = (x < z ?<= if C) && (y < z ?<= if C).
Proof. by case: C; rewrite /= (comparable_ge_max, comparable_gt_max). Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_lteif_maxl
| |
comparable_minA: min x (min y z) = min (min x y) z.
Proof.
move: cmp_xy cmp_xz cmp_yz; rewrite !(fun_if, if_arg)/= !lt_le_def.
case/boolP: (x <= y) => xy;
case/boolP: (y <= x) => yx;
case/boolP: (x <= z) => xz;
case/boolP: (z <= x) => zx;
case/boolP: (y <= z) => yz;
case/boolP: (z <= y) => zy //= _ _ _.
- by move: zx; rewrite (le_trans zy yx).
- by move: zx; rewrite (le_trans zy yx).
- by move: zy; rewrite (le_trans zx xy).
- by move: zy; rewrite (le_trans zx xy).
- by move: zx; rewrite (le_trans zy yx).
- by move: zx; rewrite (le_trans zy yx).
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_minA
| |
comparable_maxA: max x (max y z) = max (max x y) z.
Proof.
move: cmp_xy cmp_xz cmp_yz; rewrite !(fun_if, if_arg)/= !lt_le_def.
case/boolP: (x <= y) => xy;
case/boolP: (y <= x) => yx;
case/boolP: (x <= z) => xz;
case/boolP: (z <= x) => zx;
case/boolP: (y <= z) => yz;
case/boolP: (z <= y) => zy //= _ _ _.
- by move: zx; rewrite (le_trans zy yx).
- by move: zx; rewrite (le_trans zy yx).
- by move: zy; rewrite (le_trans zx xy).
- by move: zy; rewrite (le_trans zx xy).
- by move: zx; rewrite (le_trans zy yx).
- by move: zx; rewrite (le_trans zy yx).
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_maxA
| |
comparable_min_maxl: min (max x y) z = max (min x z) (min y z).
Proof.
move: cmp_xy cmp_xz cmp_yz; rewrite !(fun_if, if_arg)/= !lt_le_def.
case/boolP: (x <= y) => xy;
case/boolP: (y <= x) => yx;
case/boolP: (x <= z) => xz;
case/boolP: (z <= x) => zx;
case/boolP: (y <= z) => yz;
case/boolP: (z <= y) => zy;
rewrite ?lexx => //= _ _ _.
- by move: zx; rewrite (le_trans zy yx).
- by move: zx; rewrite (le_trans zy yx).
- by move: zy; rewrite (le_trans zx xy).
- by move: zy; rewrite (le_trans zx xy).
- by move: zx; rewrite (le_trans zy yx).
- by move: zx; rewrite (le_trans zy yx).
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_min_maxl
| |
comparable_max_minr:
max x (min y z) = min (max x y) (max x z).
Proof.
move: cmp_xy cmp_xz cmp_yz; rewrite !(fun_if, if_arg)/= !lt_le_def.
case/boolP: (x <= y) => xy;
case/boolP: (y <= x) => yx;
case/boolP: (x <= z) => xz;
case/boolP: (z <= x) => zx;
case/boolP: (y <= z) => yz;
case/boolP: (z <= y) => zy;
rewrite ?lexx => //= _ _ _.
- by move: zx; rewrite (le_trans zy yx).
- by move: zx; rewrite (le_trans zy yx).
- by move: zy; rewrite (le_trans zx xy).
- by move: zy; rewrite (le_trans zx xy).
- by move: zx; rewrite (le_trans zy yx).
- by move: zx; rewrite (le_trans zy yx).
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_max_minr
| |
comparable_arg_minP: extremum_spec <=%O P F (arg_min i0 P F).
Proof.
by apply: extremum_inP => // [x _|y x z _ _ _]; [apply: lexx|apply: le_trans].
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_arg_minP
| |
comparable_arg_maxP: extremum_spec >=%O P F (arg_max i0 P F).
Proof.
apply: extremum_inP => // [x _|y x z _ _ _|]; [exact: lexx|exact: ge_trans|].
by move=> x y xP yP; rewrite orbC [_ || _]F_comparable.
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_arg_maxP
| |
comparable_biglx x0 op I (P : pred I) F (s : seq I) :
{in >=< x &, forall y z, op y z >=< x} -> x0 >=< x ->
{in P, forall i, F i >=< x} -> \big[op/x0]_(i <- s | P i) F i >=< x.
Proof. by move=> *; elim/big_ind : _. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_bigl
| |
comparable_bigrx x0 op I (P : pred I) F (s : seq I) :
{in >=<%O x &, forall y z, x >=< op y z} -> x >=< x0 ->
{in P, forall i, x >=< F i} -> x >=< \big[op/x0]_(i <- s | P i) F i.
Proof. by move=> *; elim/big_ind : _. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_bigr
| |
bigmax_lt: x0 < x -> (forall i, P i -> f i < x) ->
\big[max/x0]_(i <- r | P i) f i < x.
Proof. by move=> ? ?; elim/big_ind: _ => // *; rewrite maxElt; case: ifPn. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
bigmax_lt
| |
lt_bigmin: x < x0 -> (forall i, P i -> x < f i) ->
x < \big[min/x0]_(i <- r | P i) f i.
Proof. by move=> ? ?; elim/big_ind: _ => // *; rewrite minElt; case: ifPn. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
lt_bigmin
| |
comparable_contraTleb x y : x >=< y -> (y < x -> ~~ b) -> (b -> x <= y).
Proof. by move=> /comparable_leNgt ->; case: (y < x); case: b. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contraTle
| |
comparable_contraTltb x y : x >=< y -> (y <= x -> ~~ b) -> (b -> x < y).
Proof. by move=> /comparable_ltNge ->; case: (y <= x); case: b. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contraTlt
| |
comparable_contraPleP x y : x >=< y -> (y < x -> ~ P) -> (P -> x <= y).
Proof. by move=> /comparable_leNgt -> np p; apply/negP => /np. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contraPle
| |
comparable_contraPltP x y : x >=< y -> (y <= x -> ~ P) -> (P -> x < y).
Proof. by move=> /comparable_ltNge -> np p; apply/negP => /np. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contraPlt
| |
comparable_contraNleb x y : x >=< y -> (y < x -> b) -> (~~ b -> x <= y).
Proof. by move=> /comparable_leNgt ->; case: (y < x); case: b. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contraNle
| |
comparable_contraNltb x y : x >=< y -> (y <= x -> b) -> (~~ b -> x < y).
Proof. by move=> /comparable_ltNge ->; case: (y <= x); case: b. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contraNlt
| |
comparable_contra_not_leP x y : x >=< y -> (y < x -> P) -> (~ P -> x <= y).
Proof. by move=> /comparable_leNgt -> np p; apply/negP => /np. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contra_not_le
| |
comparable_contra_not_ltP x y : x >=< y -> (y <= x -> P) -> (~ P -> x < y).
Proof. by move=> /comparable_ltNge -> np p; apply/negP => /np. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contra_not_lt
| |
comparable_contraFleb x y : x >=< y -> (y < x -> b) -> (b = false -> x <= y).
Proof. by move=> /comparable_leNgt -> np /negP p; apply/negP => /np. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contraFle
| |
comparable_contraFltb x y : x >=< y -> (y <= x -> b) -> (b = false -> x < y).
Proof. by move=> /comparable_ltNge -> np /negP p; apply/negP => /np. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contraFlt
| |
comparable_contra_leq_lem n x y : x >=< y ->
(y < x -> (n < m)%N) -> ((m <= n)%N -> x <= y).
Proof. by rewrite ltnNge; apply/comparable_contraTle. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contra_leq_le
| |
comparable_contra_leq_ltm n x y : x >=< y ->
(y <= x -> (n < m)%N) -> ((m <= n)%N -> x < y).
Proof. by rewrite ltnNge; apply/comparable_contraTlt. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contra_leq_lt
| |
comparable_contra_ltn_lem n x y : x >=< y ->
(y < x -> (n <= m)%N) -> ((m < n)%N -> x <= y).
Proof. by rewrite ltnNge; apply/comparable_contraNle. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contra_ltn_le
| |
comparable_contra_ltn_ltm n x y : x >=< y ->
(y <= x -> (n <= m)%N) -> ((m < n)%N -> x < y).
Proof. by rewrite ltnNge; apply/comparable_contraNlt. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contra_ltn_lt
| |
comparable_contra_lex y z t : z >=< t ->
(t < z -> y < x) -> (x <= y -> z <= t).
Proof.
rewrite /comparable lt_le_def; case: (z <= t) => //= -> /(_ erefl) yx.
by move=> /(lt_le_trans yx); rewrite ltxx.
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contra_le
| |
comparable_contra_le_ltx y z t : z >=< t ->
(t <= z -> y < x) -> (x <= y -> z < t).
Proof.
rewrite /comparable [z < t]lt_le_def orbC; case: (t <= z) => /= [_|-> //].
by move=> /(_ erefl) yx /(lt_le_trans yx); rewrite ltxx.
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contra_le_lt
| |
comparable_contra_lt_lex y z t : z >=< t ->
(t < z -> y <= x) -> (x < y -> z <= t).
Proof.
rewrite /comparable lt_le_def; case: (z <= t) => //= -> /(_ erefl) yx.
by move=> /(le_lt_trans yx); rewrite ltxx.
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contra_lt_le
| |
comparable_contra_ltx y z t : z >=< t ->
(t <= z -> y <= x) -> (x < y -> z < t).
Proof.
rewrite /comparable [z < t]lt_le_def orbC; case: (t <= z) => /= [_|-> //].
by move=> /(_ erefl) yx /(le_lt_trans yx); rewrite ltxx.
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
comparable_contra_lt
| |
leW_mono: {mono f : x y / x <= y} -> {mono f : x y / x < y}.
Proof. by move=> fmono x y; rewrite !lt_le_def !fmono. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
leW_mono
| |
leW_nmono: {mono f : x y /~ x <= y} -> {mono f : x y /~ x < y}.
Proof. by move=> fmono x y; rewrite !lt_le_def !fmono. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
leW_nmono
| |
leW_mono_in:
{in D &, {mono f : x y / x <= y}} -> {in D &, {mono f : x y / x < y}}.
Proof. by move=> fmono x y xD yD; rewrite !lt_le_def !fmono. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
leW_mono_in
| |
leW_nmono_in:
{in D &, {mono f : x y /~ x <= y}} -> {in D &, {mono f : x y /~ x < y}}.
Proof. by move=> fmono x y xD yD; rewrite !lt_le_def !fmono. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
leW_nmono_in
| |
le0xx : \bot <= x. Proof. exact: le0x. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
le0x
| |
ltx0x : (x < \bot) = false.
Proof. exact/le_gtF/le0x. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
ltx0
| |
lex1x : x <= \top. Proof. exact: lex1. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
lex1
| |
lt1xx : (\top < x) = false. Proof. exact: (@ltx0 _ T^d). Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
lt1x
| |
RecordisPreorder (d : disp_t) T of Equality T := {
le : rel T;
lt : rel T;
lt_def : forall x y, lt x y = (le x y) && ~~ (le y x);
le_refl : reflexive le;
le_trans : transitive le;
}.
HB.builders Context (d : disp_t) T of isPreorder d T.
|
HB.factory
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
Record
| |
Definition_ := @isDuallyPreorder.Build d T
le _ lt_def (fun x y => lt_def y x) le_refl le_refl le_trans ge_trans.
HB.end.
HB.factory Record Le_isPreorder (d : disp_t) T of Equality T := {
le : rel T;
le_refl : reflexive le;
le_trans : transitive le;
}.
HB.builders Context (d : disp_t) T of Le_isPreorder d T.
|
HB.instance
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
Definition
| |
Definition_ := @isPreorder.Build d T
le _ (fun _ _ => erefl) le_refl le_trans.
HB.end.
HB.factory Record LtLe_isPreorder (d : disp_t) T of Equality T := {
le : rel T;
lt : rel T;
le_def : forall x y, le x y = (x == y) || lt x y;
lt_irr : irreflexive lt;
lt_trans : transitive lt;
}.
HB.builders Context (d : disp_t) T of LtLe_isPreorder d T.
Let le_refl : reflexive le. Proof. by move=> x; rewrite le_def eqxx. Qed.
Let le_trans : transitive le.
Proof.
move=> y x z; rewrite !le_def; case: (eqVneq x y) => [->|]//= neq_xy.
by case: (eqVneq y z) => /= [<- ->|_ /lt_trans yx /yx ->]; rewrite orbT.
Qed.
Let lt_le_def x y : lt x y = (le x y) && ~~ (le y x).
Proof.
rewrite !le_def eq_sym; have [->|_ /=] := eqVneq x y; first by rewrite lt_irr.
case/boolP: (lt x y) => //= xy; apply/esym/negP => /(lt_trans xy).
by rewrite lt_irr.
Qed.
#[warning="-HB.no-new-instance"]
HB.instance Definition _ := @isPreorder.Build d T
le lt lt_le_def le_refl le_trans .
HB.end.
HB.factory Record Lt_isPreorder (d : disp_t) T of Equality T := {
lt : rel T;
lt_irr : irreflexive lt;
lt_trans : transitive lt;
}.
|
HB.instance
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
Definition
| |
le(x y : T) := f x <= f y.
|
Definition
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
le
| |
lt(x y : T) := f x < f y.
Fact refl : reflexive le. Proof. by move=> ?; apply: lexx. Qed.
Fact trans : transitive le. Proof. by move=> ? ? ?; apply: le_trans. Qed.
Fact ge_trans : transitive (fun x y => le y x). Proof. by move=> ? ? ?; apply: ge_trans. Qed.
Fact lt_le_def x y : lt x y = le x y && ~~ le y x.
Proof. exact: lt_le_def. Qed.
|
Definition
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
lt
| |
PrePcan:= isPreorder.Build disp T lt_le_def refl trans.
|
Definition
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
PrePcan
| |
Definition_ (disp : disp_t) (T : choiceType)
(disp' : disp_t) (T' : porderType disp') (f : T -> T')
(f_inj : injective f): isPreorder disp (inj_type f_inj) :=
@PreCancelPartial.PrePcan disp (inj_type f_inj) disp' T' f.
*)
#[export]
HB.instance Definition _ (disp : disp_t) (T : Type)
(disp' : disp_t) (T' : preorderType disp') (f : T -> T')
(f' : T' -> option T) (f_can : pcancel f f') : isPreorder disp (pcan_type f_can) :=
@PreCancelPartial.PrePcan disp (pcan_type f_can) disp' T' f.
#[export]
HB.instance Definition _ (disp : disp_t) (T : Type)
(disp' : disp_t) (T' : preorderType disp') (f : T -> T')
(f' : T' -> T) (f_can : cancel f f') : isPreorder disp (can_type f_can) :=
@PreCancelPartial.PrePcan disp (can_type f_can) disp' T' f.
|
HB.instance
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
Definition
| |
order_morphismd (T : preorderType d) d' (T' : preorderType d')
(f : T -> T') : Prop := {mono f : x y / x <= y}.
HB.mixin Record isOrderMorphism d (T : preorderType d) d' (T' : preorderType d')
(apply : T -> T') := {
omorph_le_subproof : {homo apply : x y / x <= y} ;
}.
HB.structure Definition OrderMorphism d (T : preorderType d)
d' (T' : preorderType d') := {f of isOrderMorphism d T d' T' f}.
|
Definition
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
order_morphism
| |
omorph_le(d : disp_t) (T : preorderType d) (d' : disp_t) (T' : preorderType d')
(f : {omorphism T -> T'}) : {homo f : x y / x <= y}.
Proof. exact: omorph_le_subproof. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
omorph_le
| |
Definition_ := isOrderMorphism.Build d T d T idfun
idfun_is_nondecreasing.
Fact comp_is_nondecreasing : nondecreasing (f \o g).
Proof. by move=> ? ? ?; do 2 apply: omorph_le. Qed.
#[export]
HB.instance Definition _ := isOrderMorphism.Build d T d'' T'' (f \o g)
comp_is_nondecreasing.
|
HB.instance
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
Definition
| |
RecordisSubPreorder d (T : preorderType d) (S : pred T) d' U
of SubType T S U & Preorder d' U := {
le_val : {mono (val : U -> T) : x y / x <= y};
}.
#[short(type="subPreorder")]
HB.structure Definition SubPreorder d (T : preorderType d) S d' :=
{ U of SubEquality T S U & Preorder d' U & isSubPreorder d T S d' U }.
|
HB.mixin
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
Record
| |
leEsubx y : (x <= y) = (val x <= val y). Proof. by rewrite le_val. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
leEsub
| |
lt_val: {mono val : x y / x < y}.
Proof. by move=> x y; rewrite !lt_leAnge !le_val. Qed.
#[deprecated(since="mathcomp 2.3.0", note="Use lt_val instead.")]
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
lt_val
| |
ltEsubx y : (x < y) = (val x < val y). Proof. by rewrite lt_val. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
ltEsub
| |
le_wval: {homo val : x y / x <= y}. Proof. exact/mono2W/le_val. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
le_wval
| |
lt_wval: {homo val : x y / x < y}. Proof. exact/mono2W/lt_val. Qed.
HB.instance Definition _ := isOrderMorphism.Build d' U d T val le_wval.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
lt_wval
| |
RecordSubChoice_isSubPreorder d (T : preorderType d) S (d' : disp_t) U
of SubChoice T S U := {}.
HB.builders Context d T S d' U of SubChoice_isSubPreorder d T S d' U.
HB.instance Definition _ : isPreorder d' U :=
@PreCancelPartial.PrePcan d' U d T val.
Fact valD : order_morphism (val : U -> T). Proof. by []. Qed.
HB.instance Definition _ := isSubPreorder.Build d T S d' U valD.
HB.end.
|
HB.factory
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
Record
| |
ltn_defx y : (x < y)%N = (x <= y)%N && ~~ (y <= x)%N.
Proof. by rewrite -ltnNge andbC; case: (ltnP x y) => //= /ltnW. Qed.
#[export]
HB.instance Definition _ :=
isPreorder.Build nat_display nat ltn_def leqnn leq_trans.
#[export]
HB.instance Definition _ := hasBottom.Build nat_display nat leq0n.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
ltn_def
| |
leEnat: le = leq. Proof. by []. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
leEnat
| |
ltEnat: lt = ltn. Proof. by []. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
ltEnat
| |
minEnat: min = minn. Proof. by []. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
minEnat
| |
maxEnat: max = maxn. Proof. by []. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
maxEnat
| |
botEnat: \bot = 0%N :> nat. Proof. by []. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
botEnat
| |
leEnat:= leEnat.
|
Definition
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
leEnat
| |
ltEnat:= ltEnat.
|
Definition
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
ltEnat
| |
minEnat:= minEnat.
|
Definition
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
minEnat
| |
maxEnat:= maxEnat.
|
Definition
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
maxEnat
| |
botEnat:= botEnat.
|
Definition
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
botEnat
| |
homo_ltn_lt_in: {in D, forall i, i.+1 \in D -> f i < f i.+1} ->
{in D &, {homo f : i j / i < j}}.
Proof. by apply: homo_ltn_in Dconvex; apply: lt_trans. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
homo_ltn_lt_in
| |
nondecn_inP: {in D, forall i, i.+1 \in D -> f i <= f i.+1} ->
{in D &, {homo f : i j / i <= j}}.
Proof. by apply: homo_leq_in Dconvex => //; apply: le_trans. Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
nondecn_inP
| |
nhomo_ltn_lt_in: {in D, forall i, i.+1 \in D -> f i > f i.+1} ->
{in D &, {homo f : i j /~ i < j}}.
Proof.
move=> f_dec; apply: homo_sym_in.
by apply: homo_ltn_in Dconvex f_dec => ? ? ? ? /lt_trans->.
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
nhomo_ltn_lt_in
| |
nonincn_inP: {in D, forall i, i.+1 \in D -> f i >= f i.+1} ->
{in D &, {homo f : i j /~ i <= j}}.
Proof.
move=> /= f_dec; apply: homo_sym_in.
by apply: homo_leq_in Dconvex f_dec => //= ? ? ? ? /le_trans->.
Qed.
|
Lemma
|
order
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat choice seq",
"From mathcomp Require Import path fintype tuple bigop finset div prime finfun",
"From mathcomp Require Import finset"
] |
order/preorder.v
|
nonincn_inP
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.