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 |
|---|---|---|---|---|---|---|
zprimitive_irrp a q :
p != 0 -> zprimitive p = a *: q -> a = sgz (lead_coef q).
Proof.
move=> nz_p Dp; have: p = (a * zcontents p) *: q.
by rewrite mulrC -scalerA -Dp -zpolyEprim.
case/zprimitive_min=> // b <- /eqP.
rewrite Dp -{1}[q]scale1r scalerA -subr_eq0 -scalerBl scale_poly_eq0 subr_eq0.
have{Dp} /negPf->: q != 0.
by apply: contraNneq nz_p; rewrite -zprimitive_eq0 Dp => ->; rewrite scaler0.
by case: b a => [[|[|b]] | [|b]] [[|[|a]] | [|a]] //; rewrite mulr0.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq path",
"From mathcomp Require Import div choice fintype tuple prime order",
"From mathcomp Require Import ssralg poly ssrnum ssrint matrix",
"From mathcomp Require Import polydiv perm zmodp bigop"
] |
algebra/intdiv.v
|
zprimitive_irr
| |
zcontentsMp q : zcontents (p * q) = zcontents p * zcontents q.
Proof.
have [-> | nz_p] := eqVneq p 0; first by rewrite !(mul0r, zcontents0).
have [-> | nz_q] := eqVneq q 0; first by rewrite !(mulr0, zcontents0).
rewrite -[zcontents q]mulr1 {1}[p]zpolyEprim {1}[q]zpolyEprim.
rewrite -scalerAl -scalerAr !zcontentsZ; congr (_ * (_ * _)).
rewrite [zcontents _]intEsg sgz_contents lead_coefM sgzM !sgz_lead_primitive.
apply/eqP; rewrite nz_p nz_q !mul1r [_ == _]eqn_leq absz_gt0 zcontents_eq0.
rewrite mulf_neq0 ?zprimitive_eq0 // andbT leqNgt.
apply/negP=> /pdivP[r r_pr r_dv_d]; pose to_r : int -> 'F_r := intr.
have nz_prim_r q1: q1 != 0 -> map_poly to_r (zprimitive q1) != 0.
move=> nz_q1; apply: contraTneq (prime_gt1 r_pr) => r_dv_q1.
rewrite -leqNgt dvdn_leq // -(dvdzE r true) -nz_q1 -zcontents_primitive.
rewrite dvdz_contents; apply/polyOverP=> i /=; rewrite dvdzE /=.
have /polyP/(_ i)/eqP := r_dv_q1; rewrite coef_map coef0 /=.
rewrite {1}[_`_i]intEsign rmorphM /= rmorph_sign /= mulf_eq0 signr_eq0 /=.
by rewrite -val_eqE /= val_Fp_nat.
suffices{nz_prim_r} /idPn[]: map_poly to_r (zprimitive p * zprimitive q) == 0.
by rewrite rmorphM mulf_neq0 ?nz_prim_r.
rewrite [_ * _]zpolyEprim [zcontents _]intEsign mulrC -scalerA map_polyZ /=.
by rewrite scale_poly_eq0 -val_eqE /= val_Fp_nat ?(eqnP r_dv_d).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq path",
"From mathcomp Require Import div choice fintype tuple prime order",
"From mathcomp Require Import ssralg poly ssrnum ssrint matrix",
"From mathcomp Require Import polydiv perm zmodp bigop"
] |
algebra/intdiv.v
|
zcontentsM
| |
zprimitiveMp q : zprimitive (p * q) = zprimitive p * zprimitive q.
Proof.
have [pq_0|] := eqVneq (p * q) 0.
rewrite pq_0; move/eqP: pq_0; rewrite mulf_eq0.
by case/pred2P=> ->; rewrite !zprimitive0 (mul0r, mulr0).
rewrite -zcontents_eq0 -polyC_eq0 => /mulfI; apply; rewrite !mul_polyC.
by rewrite -zpolyEprim zcontentsM -scalerA scalerAr scalerAl -!zpolyEprim.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq path",
"From mathcomp Require Import div choice fintype tuple prime order",
"From mathcomp Require Import ssralg poly ssrnum ssrint matrix",
"From mathcomp Require Import polydiv perm zmodp bigop"
] |
algebra/intdiv.v
|
zprimitiveM
| |
dvdpP_intp q : p %| q -> {r | q = zprimitive p * r}.
Proof.
case/Pdiv.Idomain.dvdpP/sig2_eqW=> [[c r] /= nz_c Dpr].
exists (zcontents q *: zprimitive r); rewrite -scalerAr.
by rewrite -zprimitiveM mulrC -Dpr zprimitiveZ // -zpolyEprim.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq path",
"From mathcomp Require Import div choice fintype tuple prime order",
"From mathcomp Require Import ssralg poly ssrnum ssrint matrix",
"From mathcomp Require Import polydiv perm zmodp bigop"
] |
algebra/intdiv.v
|
dvdpP_int
| |
int_Smith_normal_formm n (M : 'M[int]_(m, n)) :
{L : 'M[int]_m & L \in unitmx &
{R : 'M[int]_n & R \in unitmx &
{d : seq int | sorted dvdz d &
M = L *m (\matrix_(i, j) (d`_i *+ (i == j :> nat))) *m R}}}.
Proof.
move: {2}_.+1 (ltnSn (m + n)) => mn.
elim: mn => // mn IHmn in m n M *; rewrite ltnS => le_mn.
have [[i j] nzMij | no_ij] := pickP (fun k => M k.1 k.2 != 0); last first.
do 2![exists 1%:M; first exact: unitmx1]; exists nil => //=.
apply/matrixP=> i j; apply/eqP; rewrite mulmx1 mul1mx mxE nth_nil mul0rn.
exact: negbFE (no_ij (i, j)).
do [case: m i => [[]//|m] i; case: n j => [[]//|n] j /=] in M nzMij le_mn *.
wlog Dj: j M nzMij / j = 0; last rewrite {j}Dj in nzMij.
case/(_ 0 (xcol j 0 M)); rewrite ?mxE ?tpermR // => L uL [R uR [d dvD dM]].
exists L => //; exists (xcol j 0 R); last exists d => //=.
by rewrite xcolE unitmx_mul uR unitmx_perm.
by rewrite xcolE !mulmxA -dM xcolE -mulmxA -perm_mxM tperm2 perm_mx1 mulmx1.
move Da: (M i 0) nzMij => a nz_a.
have [A leA] := ubnP `|a|; elim: A => // A IHa in a leA m n M i Da nz_a le_mn *.
wlog [j a'Mij]: m n M i Da le_mn / {j | ~~ (a %| M i j)%Z}; last first.
have nz_j: j != 0 by apply: contraNneq a'Mij => ->; rewrite Da.
case: n => [[[]//]|n] in j le_mn nz_j M a'Mij Da *.
wlog{nz_j} Dj: j M a'Mij Da / j = 1; last rewrite {j}Dj in a'Mij.
case/(_ 1 (xcol j 1 M)); rewrite ?mxE ?tpermR ?tpermD //.
move=> L uL [R uR [d dvD dM]]; exists L => //.
exists (xcol j 1 R); first by rewrite xcolE unitmx_mul uR unitmx_pe
...
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq path",
"From mathcomp Require Import div choice fintype tuple prime order",
"From mathcomp Require Import ssralg poly ssrnum ssrint matrix",
"From mathcomp Require Import polydiv perm zmodp bigop"
] |
algebra/intdiv.v
|
int_Smith_normal_form
| |
itv_bound(T : Type) : Type := BSide of bool & T | BInfty of bool.
|
Variant
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_bound
| |
BLeft:= (BSide true).
|
Notation
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
BLeft
| |
BRight:= (BSide false).
|
Notation
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
BRight
| |
interval(T : Type) := Interval of itv_bound T & itv_bound T.
|
Variant
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
interval
| |
pair_of_intervalT (I : interval T) : itv_bound T * itv_bound T :=
let: Interval b1 b2 := I in (b1, b2).
|
Coercion
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
pair_of_interval
| |
itv_bound_can:
cancel (fun b : itv_bound T =>
match b with BSide b x => (b, Some x) | BInfty b => (b, None) end)
(fun b =>
match b with (b, Some x) => BSide b x | (b, None) => BInfty _ b end).
Proof. by case. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_bound_can
| |
interval_can:
@cancel _ (interval T)
(fun '(Interval b1 b2) => (b1, b2)) (fun '(b1, b2) => Interval b1 b2).
Proof. by case. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
interval_can
| |
Definition_ (T : eqType) := Equality.copy (itv_bound T)
(can_type (@itv_bound_can T)).
#[export, hnf]
HB.instance Definition _ (T : eqType) := Equality.copy (interval T)
(can_type (@interval_can T)).
#[export, hnf]
HB.instance Definition _ (T : choiceType) := Choice.copy (itv_bound T)
(can_type (@itv_bound_can T)).
#[export, hnf]
HB.instance Definition _ (T : choiceType) := Choice.copy (interval T)
(can_type (@interval_can T)).
#[export, hnf]
HB.instance Definition _ (T : countType) := Countable.copy (itv_bound T)
(can_type (@itv_bound_can T)).
#[export, hnf]
HB.instance Definition _ (T : countType) := Countable.copy (interval T)
(can_type (@interval_can T)).
#[export, hnf]
HB.instance Definition _ (T : finType) := Finite.copy (itv_bound T)
(can_type (@itv_bound_can T)).
#[export, hnf]
HB.instance Definition _ (T : finType) := Finite.copy (interval T)
(can_type (@interval_can T)).
|
HB.instance
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
Definition
| |
le_boundb1 b2 :=
match b1, b2 with
| -oo, _ | _, +oo => true
| BSide b1 x1, BSide b2 x2 => x1 < x2 ?<= if b2 ==> b1
| _, _ => false
end.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
le_bound
| |
lt_boundb1 b2 :=
match b1, b2 with
| -oo, +oo | -oo, BSide _ _ | BSide _ _, +oo => true
| BSide b1 x1, BSide b2 x2 => x1 < x2 ?<= if b1 && ~~ b2
| _, _ => false
end.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
lt_bound
| |
lt_bound_defb1 b2 : lt_bound b1 b2 = (b2 != b1) && le_bound b1 b2.
Proof. by case: b1 b2 => [[]?|[]][[]?|[]] //=; rewrite lt_def. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
lt_bound_def
| |
le_bound_refl: reflexive le_bound.
Proof. by move=> [[]?|[]] /=. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
le_bound_refl
| |
le_bound_anti: antisymmetric le_bound.
Proof. by case=> [[]?|[]] [[]?|[]] //=; case: comparableP => // ->. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
le_bound_anti
| |
le_bound_trans: transitive le_bound.
Proof.
by case=> [[]?|[]] [[]?|[]] [[]?|[]] lexy leyz //;
apply: (lteif_imply _ (lteif_trans lexy leyz)).
Qed.
HB.instance Definition _ :=
Order.isPOrder.Build (itv_bound_display disp) (itv_bound T)
lt_bound_def le_bound_refl le_bound_anti le_bound_trans.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
le_bound_trans
| |
bound_lexxc1 c2 x : (BSide c1 x <= BSide c2 x) = (c2 ==> c1).
Proof. by rewrite /<=%O /= lteifxx. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_lexx
| |
bound_ltxxc1 c2 x : (BSide c1 x < BSide c2 x) = (c1 && ~~ c2).
Proof. by rewrite /<%O /= lteifxx. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_ltxx
| |
ge_pinftyb : (+oo <= b) = (b == +oo). Proof. by case: b => [|] []. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
ge_pinfty
| |
le_ninftyb : (b <= -oo) = (b == -oo). Proof. by case: b => // - []. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
le_ninfty
| |
gt_pinftyb : (+oo < b) = false. Proof. by []. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
gt_pinfty
| |
lt_ninftyb : (b < -oo) = false. Proof. by case: b => // -[]. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
lt_ninfty
| |
ltBSidex y (b b' : bool) :
BSide b x < BSide b' y = (x < y ?<= if b && ~~ b').
Proof. by []. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
ltBSide
| |
leBSidex y (b b' : bool) :
BSide b x <= BSide b' y = (x < y ?<= if b' ==> b).
Proof. by []. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
leBSide
| |
lteBSide:= (ltBSide, leBSide).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
lteBSide
| |
ltBRight_leBLeftb x : b < BRight x = (b <= BLeft x).
Proof. by move: b => [[] b|[]]. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
ltBRight_leBLeft
| |
leBRight_ltBLeftb x : BRight x <= b = (BLeft x < b).
Proof. by move: b => [[] b|[]]. Qed.
Let BLeft_ltE x y (b : bool) : BSide b x < BLeft y = (x < y).
Proof. by case: b. Qed.
Let BRight_leE x y (b : bool) : BSide b x <= BRight y = (x <= y).
Proof. by case: b. Qed.
Let BRight_BLeft_leE x y : BRight x <= BLeft y = (x < y).
Proof. by []. Qed.
Let BLeft_BRight_ltE x y : BLeft x < BRight y = (x <= y).
Proof. by []. Qed.
Let BRight_BSide_ltE x y (b : bool) : BRight x < BSide b y = (x < y).
Proof. by case: b. Qed.
Let BLeft_BSide_leE x y (b : bool) : BLeft x <= BSide b y = (x <= y).
Proof. by case: b. Qed.
Let BSide_ltE x y (b : bool) : BSide b x < BSide b y = (x < y).
Proof. by case: b. Qed.
Let BSide_leE x y (b : bool) : BSide b x <= BSide b y = (x <= y).
Proof. by case: b. Qed.
Let BInfty_leE a : a <= BInfty T false. Proof. by case: a => [[] a|[]]. Qed.
Let BInfty_geE a : BInfty T true <= a. Proof. by case: a => [[] a|[]]. Qed.
Let BInfty_le_eqE a : BInfty T false <= a = (a == BInfty T false).
Proof. by case: a => [[] a|[]]. Qed.
Let BInfty_ge_eqE a : a <= BInfty T true = (a == BInfty T true).
Proof. by case: a => [[] a|[]]. Qed.
Let BInfty_ltE a : a < BInfty T false = (a != BInfty T false).
Proof. by case: a => [[] a|[]]. Qed.
Let BInfty_gtE a : BInfty T true < a = (a != BInfty T true).
Proof. by case: a => [[] a|[]]. Qed.
Let BInfty_ltF a : BInfty T false < a = false.
Proof. by case: a => [[] a|[]]. Qed.
Let BInfty_gtF a : a < BInfty T true = false.
Proof. by case: a => [[] a|[]]. Qed.
Let BI
...
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
leBRight_ltBLeft
| |
bnd_simp:= (BLeft_ltE, BRight_leE,
BRight_BLeft_leE, BLeft_BRight_ltE,
BRight_BSide_ltE, BLeft_BSide_leE, BSide_ltE, BSide_leE,
BInfty_leE, BInfty_geE, BInfty_BInfty_ltE,
BInfty_le_eqE, BInfty_ge_eqE, BInfty_ltE, BInfty_gtE, BInfty_ltF, BInfty_gtF,
@lexx _ T, @ltxx _ T, @eqxx T).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bnd_simp
| |
comparable_BSide_mins (x y : T) : (x >=< y)%O ->
BSide s (Order.min x y) = Order.min (BSide s x) (BSide s y).
Proof. by rewrite !minEle bnd_simp => /comparable_leP[]. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
comparable_BSide_min
| |
comparable_BSide_maxs (x y : T) : (x >=< y)%O ->
BSide s (Order.max x y) = Order.max (BSide s x) (BSide s y).
Proof. by rewrite !maxEle bnd_simp => /comparable_leP[]. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
comparable_BSide_max
| |
subitvi1 i2 :=
let: Interval b1l b1r := i1 in
let: Interval b2l b2r := i2 in (b2l <= b1l) && (b1r <= b2r).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subitv
| |
subitv_refl: reflexive subitv.
Proof. by case=> /= ? ?; rewrite !lexx. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subitv_refl
| |
subitv_anti: antisymmetric subitv.
Proof.
by case=> [? ?][? ?]; rewrite andbACA => /andP[] /le_anti -> /le_anti ->.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subitv_anti
| |
subitv_trans: transitive subitv.
Proof.
case=> [yl yr][xl xr][zl zr] /andP [Hl Hr] /andP [Hl' Hr'] /=.
by rewrite (le_trans Hl' Hl) (le_trans Hr Hr').
Qed.
HB.instance Definition _ :=
Order.isPOrder.Build (interval_display disp) (interval T)
(fun _ _ => erefl) subitv_refl subitv_anti subitv_trans.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subitv_trans
| |
pred_of_itvi : pred T := [pred x | `[x, x] <= i].
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
pred_of_itv
| |
StructureitvPredType := PredType pred_of_itv.
|
Canonical
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
Structure
| |
subitvEb1l b1r b2l b2r :
(Interval b1l b1r <= Interval b2l b2r) = (b2l <= b1l) && (b1r <= b2r).
Proof. by []. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subitvE
| |
in_itvx i :
x \in i =
let: Interval l u := i in
match l with
| BSide b lb => lb < x ?<= if b
| BInfty b => b
end &&
match u with
| BSide b ub => x < ub ?<= if ~~ b
| BInfty b => ~~ b
end.
Proof. by case: i => [[? ?|[]][|[]]]. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
in_itv
| |
itv_boundlrbl br x :
(x \in Interval bl br) = (bl <= BLeft x) && (BRight x <= br).
Proof. by []. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_boundlr
| |
itv_splitIbl br x :
x \in Interval bl br = (x \in Interval bl +oo) && (x \in Interval -oo br).
Proof. by rewrite !itv_boundlr andbT. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_splitI
| |
subitvPi1 i2 : i1 <= i2 -> {subset i1 <= i2}.
Proof. by move=> ? ? /le_trans; exact. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subitvP
| |
subset_itv(x y z u : itv_bound T) : x <= y -> z <= u ->
{subset Interval y z <= Interval x u}.
Proof. by move=> xy zu; apply: subitvP; rewrite subitvE xy zu. Qed.
#[deprecated(since="mathcomp 2.4.0", note="Use subset_itv instead.")]
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subset_itv
| |
subset_itv_bound(r s u v : bool) x y : r <= u -> v <= s ->
{subset Interval (BSide r x) (BSide s y) <= Interval (BSide u x) (BSide v y)}.
Proof.
by move: r s u v=> [] [] [] []// *; apply: subset_itv; rewrite bnd_simp.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subset_itv_bound
| |
subset_itv_oo_ccx y : {subset `]x, y[ <= `[x, y]}.
Proof. by apply: subset_itv; rewrite bnd_simp. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subset_itv_oo_cc
| |
subset_itv_oo_ocx y : {subset `]x, y[ <= `]x, y]}.
Proof. by apply: subset_itv; rewrite bnd_simp. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subset_itv_oo_oc
| |
subset_itv_oo_cox y : {subset `]x, y[ <= `[x, y[}.
Proof. by apply: subset_itv; rewrite bnd_simp. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subset_itv_oo_co
| |
subset_itv_oc_ccx y : {subset `]x, y] <= `[x, y]}.
Proof. by apply: subset_itv; rewrite bnd_simp. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subset_itv_oc_cc
| |
subset_itv_co_ccx y : {subset `[x, y[ <= `[x, y]}.
Proof. by apply: subset_itv; rewrite bnd_simp. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subset_itv_co_cc
| |
itvxxx : `[x, x] =i pred1 x.
Proof. by move=> y; rewrite in_itv/= -eq_le eq_sym. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itvxx
| |
itvxxPy x : reflect (y = x) (y \in `[x, x]).
Proof. by rewrite itvxx; apply/eqP. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itvxxP
| |
subitvPlb1l b2l br :
b2l <= b1l -> {subset Interval b1l br <= Interval b2l br}.
Proof. by move=> ?; apply: subitvP; rewrite subitvE lexx andbT. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subitvPl
| |
subitvPrbl b1r b2r :
b1r <= b2r -> {subset Interval bl b1r <= Interval bl b2r}.
Proof. by move=> ?; apply: subitvP; rewrite subitvE lexx. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
subitvPr
| |
itv_xxx cl cr y :
y \in Interval (BSide cl x) (BSide cr x) = cl && ~~ cr && (y == x).
Proof. by case: cl cr => [] []; rewrite [LHS]lteif_anti // eq_sym. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_xx
| |
boundl_in_itvc x b : x \in Interval (BSide c x) b = c && (BRight x <= b).
Proof. by rewrite itv_boundlr bound_lexx. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
boundl_in_itv
| |
boundr_in_itvc x b :
x \in Interval b (BSide c x) = ~~ c && (b <= BLeft x).
Proof. by rewrite itv_boundlr bound_lexx implybF andbC. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
boundr_in_itv
| |
bound_in_itv:= (boundl_in_itv, boundr_in_itv).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_in_itv
| |
lt_in_itvbl br x : x \in Interval bl br -> bl < br.
Proof. by case/andP; apply/le_lt_trans. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
lt_in_itv
| |
lteif_in_itvcl cr yl yr x :
x \in Interval (BSide cl yl) (BSide cr yr) -> yl < yr ?<= if cl && ~~ cr.
Proof. exact: lt_in_itv. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
lteif_in_itv
| |
itv_geb1 b2 : ~~ (b1 < b2) -> Interval b1 b2 =i pred0.
Proof. by move=> ltb12 y; apply/contraNF: ltb12; apply/lt_in_itv. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_ge
| |
itv_decomposei x : Prop :=
let: Interval l u := i in
(match l return Prop with
| BSide b lb => lb < x ?<= if b
| BInfty b => b
end *
match u return Prop with
| BSide b ub => x < ub ?<= if ~~ b
| BInfty b => ~~ b
end)%type.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_decompose
| |
itv_dec: forall x i, reflect (itv_decompose i x) (x \in i).
Proof. by move=> ? [[? ?|[]][? ?|[]]]; apply: (iffP andP); case. Qed.
Arguments itv_dec {x i}.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_dec
| |
itv_rewritei x : Type :=
let: Interval l u := i in
(match l with
| BLeft a => (a <= x) * (x < a = false)
| BRight a => (a <= x) * (a < x) * (x <= a = false) * (x < a = false)
| -oo => forall x : T, x == x
| +oo => forall b : bool, unkeyed b = false
end *
match u with
| BRight b => (x <= b) * (b < x = false)
| BLeft b => (x <= b) * (x < b) * (b <= x = false) * (b < x = false)
| +oo => forall x : T, x == x
| -oo => forall b : bool, unkeyed b = false
end *
match l, u with
| BLeft a, BRight b =>
(a <= b) * (b < a = false) * (a \in `[a, b]) * (b \in `[a, b])
| BLeft a, BLeft b =>
(a <= b) * (a < b) * (b <= a = false) * (b < a = false)
* (a \in `[a, b]) * (a \in `[a, b[) * (b \in `[a, b]) * (b \in `]a, b])
| BRight a, BRight b =>
(a <= b) * (a < b) * (b <= a = false) * (b < a = false)
* (a \in `[a, b]) * (a \in `[a, b[) * (b \in `[a, b]) * (b \in `]a, b])
| BRight a, BLeft b =>
(a <= b) * (a < b) * (b <= a = false) * (b < a = false)
* (a \in `[a, b]) * (a \in `[a, b[) * (b \in `[a, b]) * (b \in `]a, b])
| _, _ => forall x : T, x == x
end)%type.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_rewrite
| |
itvPx i : x \in i -> itv_rewrite i x.
Proof.
case: i => [[[]a|[]][[]b|[]]] /andP [] ha hb; rewrite /= ?bound_in_itv;
do ![split | apply/negbTE; rewrite (le_gtF, lt_geF)];
by [|apply: ltW | move: (lteif_trans ha hb) => //=; exact: ltW].
Qed.
Arguments itvP [x i].
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itvP
| |
itv_splitU1b x : b <= BLeft x ->
Interval b (BRight x) =i [predU1 x & Interval b (BLeft x)].
Proof.
move=> bx z; rewrite !inE/= !subitvE ?bnd_simp//= lt_neqAle.
by case: (eqVneq z x) => [->|]//=; rewrite lexx bx.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_splitU1
| |
itv_split1Ub x : BRight x <= b ->
Interval (BLeft x) b =i [predU1 x & Interval (BRight x) b].
Proof.
move=> bx z; rewrite !inE/= !subitvE ?bnd_simp//= lt_neqAle.
by case: (eqVneq z x) => [->|]//=; rewrite lexx bx.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_split1U
| |
bound_meetbl br : itv_bound T :=
match bl, br with
| -oo, _ | _, -oo => -oo
| +oo, b | b, +oo => b
| BSide xb x, BSide yb y =>
BSide (((x <= y) && xb) || ((y <= x) && yb)) (x `&` y)
end.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_meet
| |
bound_joinbl br : itv_bound T :=
match bl, br with
| -oo, b | b, -oo => b
| +oo, _ | _, +oo => +oo
| BSide xb x, BSide yb y =>
BSide ((~~ (x <= y) || yb) && (~~ (y <= x) || xb)) (x `|` y)
end.
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_join
| |
bound_meetC: commutative bound_meet.
Proof.
case=> [? ?|[]][? ?|[]] //=; rewrite meetC; congr BSide.
by case: lcomparableP; rewrite ?orbF // orbC.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_meetC
| |
bound_joinC: commutative bound_join.
Proof.
case=> [? ?|[]][? ?|[]] //=; rewrite joinC; congr BSide.
by case: lcomparableP; rewrite ?andbT // andbC.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_joinC
| |
bound_meetA: associative bound_meet.
Proof.
case=> [? x|[]][? y|[]][? z|[]] //=; rewrite !lexI meetA; congr BSide.
by case: (lcomparableP x y) => [|||->]; case: (lcomparableP y z) => [|||->];
case: (lcomparableP x z) => [|||//<-]; case: (lcomparableP x y);
rewrite //= ?andbF ?orbF ?lexx ?orbA //; case: (lcomparableP y z).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_meetA
| |
bound_joinA: associative bound_join.
Proof.
case=> [? x|[]][? y|[]][? z|[]] //=; rewrite !leUx joinA; congr BSide.
by case: (lcomparableP x y) => [|||->]; case: (lcomparableP y z) => [|||->];
case: (lcomparableP x z) => [|||//<-]; case: (lcomparableP x y);
rewrite //= ?orbT ?andbT ?lexx ?andbA //; case: (lcomparableP y z).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_joinA
| |
bound_meetKUb2 b1 : bound_join b1 (bound_meet b1 b2) = b1.
Proof.
case: b1 b2 => [? ?|[]][? ?|[]] //=;
rewrite ?meetKU ?joinxx ?leIl ?lexI ?lexx ?andbb //=; congr BSide.
by case: lcomparableP; rewrite ?orbF /= ?andbb ?orbK.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_meetKU
| |
bound_joinKIb2 b1 : bound_meet b1 (bound_join b1 b2) = b1.
Proof.
case: b1 b2 => [? ?|[]][? ?|[]] //=;
rewrite ?joinKI ?meetxx ?leUl ?leUx ?lexx ?orbb //=; congr BSide.
by case: lcomparableP; rewrite ?orbF ?orbb ?andKb.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_joinKI
| |
bound_leEmeetb1 b2 : (b1 <= b2) = (bound_meet b1 b2 == b1).
Proof.
case: b1 b2 => [[]t[][]|[][][]] //=; rewrite ?eqxx// => t';
rewrite [LHS]/<=%O /eq_op ?andbT ?andbF ?orbF/= /eq_op/= /eq_op/=;
case: lcomparableP => //=; rewrite ?eqxx//=; [| | |].
- by move/lt_eqF.
- move=> ic; apply: esym; apply: contraNF ic.
by move=> /eqP/meet_idPl; apply: le_comparable.
- by move/lt_eqF.
- move=> ic; apply: esym; apply: contraNF ic.
by move=> /eqP/meet_idPl; apply: le_comparable.
Qed.
HB.instance Definition _ :=
Order.POrder_isLattice.Build (itv_bound_display disp) (itv_bound T)
bound_meetC bound_joinC bound_meetA bound_joinA
bound_joinKI bound_meetKU bound_leEmeet.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_leEmeet
| |
bound_le0xb : -oo <= b. Proof. by []. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_le0x
| |
bound_lex1b : b <= +oo. Proof. by case: b => [|[]]. Qed.
HB.instance Definition _ :=
Order.hasBottom.Build (itv_bound_display disp) (itv_bound T) bound_le0x.
HB.instance Definition _ :=
Order.hasTop.Build (itv_bound_display disp) (itv_bound T) bound_lex1.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
bound_lex1
| |
itv_meeti1 i2 : interval T :=
let: Interval b1l b1r := i1 in
let: Interval b2l b2r := i2 in Interval (b1l `|` b2l) (b1r `&` b2r).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_meet
| |
itv_joini1 i2 : interval T :=
let: Interval b1l b1r := i1 in
let: Interval b2l b2r := i2 in Interval (b1l `&` b2l) (b1r `|` b2r).
|
Definition
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_join
| |
itv_meetC: commutative itv_meet.
Proof. by case=> [? ?][? ?] /=; rewrite meetC joinC. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_meetC
| |
itv_joinC: commutative itv_join.
Proof. by case=> [? ?][? ?] /=; rewrite meetC joinC. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_joinC
| |
itv_meetA: associative itv_meet.
Proof. by case=> [? ?][? ?][? ?] /=; rewrite meetA joinA. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_meetA
| |
itv_joinA: associative itv_join.
Proof. by case=> [? ?][? ?][? ?] /=; rewrite meetA joinA. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_joinA
| |
itv_meetKUi2 i1 : itv_join i1 (itv_meet i1 i2) = i1.
Proof. by case: i1 i2 => [? ?][? ?] /=; rewrite meetKU joinKI. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_meetKU
| |
itv_joinKIi2 i1 : itv_meet i1 (itv_join i1 i2) = i1.
Proof. by case: i1 i2 => [? ?][? ?] /=; rewrite meetKU joinKI. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_joinKI
| |
itv_leEmeeti1 i2 : (i1 <= i2) = (itv_meet i1 i2 == i1).
Proof.
by case: i1 i2 => [? ?] [? ?]; rewrite /eq_op/=/eq_op/= eq_meetl eq_joinl.
Qed.
HB.instance Definition _ :=
Order.POrder_isLattice.Build (interval_display disp) (interval T)
itv_meetC itv_joinC itv_meetA itv_joinA
itv_joinKI itv_meetKU itv_leEmeet.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_leEmeet
| |
itv_le0xi : Interval +oo -oo <= i. Proof. by case: i => [[|[]]]. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_le0x
| |
itv_lex1i : i <= `]-oo, +oo[. Proof. by case: i => [?[|[]]]. Qed.
HB.instance Definition _ :=
Order.hasBottom.Build (interval_display disp) (interval T) itv_le0x.
HB.instance Definition _ :=
Order.hasTop.Build (interval_display disp) (interval T) itv_lex1.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_lex1
| |
in_itvIx i1 i2 : x \in i1 `&` i2 = (x \in i1) && (x \in i2).
Proof. exact: lexI. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
in_itvI
| |
BSide_mins (x y : T) :
BSide s (Order.min x y) = Order.min (BSide s x) (BSide s y).
Proof. exact: comparable_BSide_min. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
BSide_min
| |
BSide_maxs (x y : T) :
BSide s (Order.max x y) = Order.max (BSide s x) (BSide s y).
Proof. exact: comparable_BSide_max. Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
BSide_max
| |
itv_bound_total: total (<=%O : rel (itv_bound T)).
Proof. by move=> [[]?|[]][[]?|[]]; rewrite /<=%O //=; case: ltgtP. Qed.
HB.instance Definition _ :=
Order.Lattice_isTotal.Build
(itv_bound_display disp) (itv_bound T) itv_bound_total.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_bound_total
| |
itv_meetUl: @left_distributive (interval T) _ Order.meet Order.join.
Proof.
by move=> [? ?][? ?][? ?]; rewrite /Order.meet /Order.join /= -meetUl -joinIl.
Qed.
HB.instance Definition _ :=
Order.Lattice_Meet_isDistrLattice.Build
(interval_display disp) (interval T) itv_meetUl.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_meetUl
| |
itv_splitUc a b : a <= c <= b ->
forall y, y \in Interval a b = (y \in Interval a c) || (y \in Interval c b).
Proof.
case/andP => leac lecb y.
rewrite !itv_boundlr !(ltNge (BLeft y) _ : (BRight y <= _) = _).
case: (leP a) (leP b) (leP c) => leay [] leby [] lecy //=.
- by case: leP lecy (le_trans lecb leby).
- by case: leP leay (le_trans leac lecy).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_splitU
| |
itv_splitUeqx a b : x \in Interval a b ->
forall y, y \in Interval a b =
[|| y \in Interval a (BLeft x), y == x | y \in Interval (BRight x) b].
Proof.
case/andP => ax xb y; rewrite (@itv_splitU (BLeft x)) ?ax ?ltW //.
by congr orb; rewrite (@itv_splitU (BRight x)) ?bound_lexx // itv_xx.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_splitUeq
| |
itv_total_meet3Ei1 i2 i3 :
i1 `&` i2 `&` i3 \in [:: i1 `&` i2; i1 `&` i3; i2 `&` i3].
Proof.
case: i1 i2 i3 => [b1l b1r] [b2l b2r] [b3l b3r]; rewrite !inE /eq_op /=.
case: (leP b1l b2l); case: (leP b1l b3l); case: (leP b2l b3l);
case: (leP b1r b2r); case: (leP b1r b3r); case: (leP b2r b3r);
rewrite ?eqxx ?orbT //= => b23r b13r b12r b23l b13l b12l.
- by case: leP b13r (le_trans b12r b23r).
- by case: leP b13l (le_trans b12l b23l).
- by case: leP b13l (le_trans b12l b23l).
- by case: leP b13r (le_trans b12r b23r).
- by case: leP b13r (le_trans b12r b23r).
- by case: leP b13l (lt_trans b23l b12l).
- by case: leP b13r (lt_trans b23r b12r).
- by case: leP b13l (lt_trans b23l b12l).
- by case: leP b13r (lt_trans b23r b12r).
- by case: leP b13r (lt_trans b23r b12r).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_total_meet3E
| |
itv_total_join3Ei1 i2 i3 :
i1 `|` i2 `|` i3 \in [:: i1 `|` i2; i1 `|` i3; i2 `|` i3].
Proof.
case: i1 i2 i3 => [b1l b1r] [b2l b2r] [b3l b3r]; rewrite !inE /eq_op /=.
case: (leP b1l b2l); case: (leP b1l b3l); case: (leP b2l b3l);
case: (leP b1r b2r); case: (leP b1r b3r); case: (leP b2r b3r);
rewrite ?eqxx ?orbT //= => b23r b13r b12r b23l b13l b12l.
- by case: leP b13r (le_trans b12r b23r).
- by case: leP b13r (le_trans b12r b23r).
- by case: leP b13l (le_trans b12l b23l).
- by case: leP b13l (le_trans b12l b23l).
- by case: leP b13l (le_trans b12l b23l).
- by case: leP b13r (lt_trans b23r b12r).
- by case: leP b13l (lt_trans b23l b12l).
- by case: leP b13l (lt_trans b23l b12l).
- by case: leP b13l (lt_trans b23l b12l).
- by case: leP b13r (lt_trans b23r b12r).
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
itv_total_join3E
| |
predC_itvla : [predC Interval -oo a] =i Interval a +oo.
Proof.
case: a => [b x|[]//] y.
by rewrite !inE !subitvE/= bnd_simp andbT !lteBSide/= lteifNE negbK.
Qed.
|
Lemma
|
algebra
|
[
"From HB Require Import structures",
"From mathcomp Require Import ssreflect ssrfun ssrbool eqtype ssrnat seq choice",
"From mathcomp Require Import div fintype bigop order ssralg finset fingroup",
"From mathcomp Require Import ssrnum"
] |
algebra/interval.v
|
predC_itvl
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.